输入输出样例

输入 #1复制

2 3

220 280

170 120 210

77 39 105

150 186 122
输出 #1复制

48500

69140zuixiaofeiyo

说明/提示

1 \leq n, m \leq 1001≤n,m≤100

思路

　　这题不应该算是个紫题吧。。

　　没啥坑，也很容易想到最大费用流就是把所有边转换为负边权后的最小费用流

　　建图也很好想

CODE

 #include <bits/stdc++.h>

 #define dbg(x) cout << #x << "=" << x << endl

 using namespace std;

 typedef long long LL;

 template<class T>inline void read(T &res)

 {

     char c;T flag=;

     while((c=getchar())<''||c>'')if(c=='-')flag=-;res=c-'';

     while((c=getchar())>=''&&c<='')res=res*+c-'';res*=flag;

 }

 const int MAXN = 2e3 + ;

 const int inf = 0x3f3f3f3f;

 int N, M;

 namespace zkw{

     struct Edge{

         int to, val, cost;

         Edge *next, *ops;

         Edge(int to, int val, int cost, Edge *next): to(to), val(val), cost(cost), next(next){}

     };

     Edge *head[MAXN << ];

     void BuildGraph(int u, int v, int w, int c) {

         head[u] = new Edge(v, w, c, head[u]);

         head[v] = new Edge(u, , -c, head[v]);

         head[u]->ops = head[v]; head[v]->ops = head[u];

     }

     int s, t, ans, res;

     int dis[MAXN << ];

     bool vis[MAXN << ];

     void init() {

         memset(dis, 0x3f, sizeof(dis));

         memset(vis, false, sizeof(vis));

         s = , t = , ans = , res = ;

     }

     bool Spfa() {

         memset(vis, false, sizeof vis);

         memset(dis, 0x3f, sizeof dis);

         deque<int> q;

         q.push_back(s);

         vis[s] = true; dis[s] = ;

         while (!q.empty()) {

             int u = q.front(); q.pop_front(); vis[u] = false;

             for (Edge *e = head[u]; e; e = e->next) {

                 int v = e->to;

                 if (e->val >  && dis[u] + e->cost < dis[v]) {

                     dis[v] = dis[u] + e->cost;

                     if (!vis[v]) {

                         vis[v] = true;

                         if (!q.empty() && dis[v] < dis[q.front()]) q.push_front(v);

                         else q.push_back(v);

                     }

                 }

             }

         }

         return dis[t] < inf;

     }

     int Dfs(int u, int flow) {

         if (u == t) {

             vis[u] = true;

             res += flow;

             return flow;

         }

         int used = ; vis[u] = true;

         for (Edge *e = head[u]; e; e = e->next) {//当前弧就不加了

             int v = e->to;

             if ((!vis[v] || v == t) && e->val && dis[u] + e->cost == dis[v]) {

                 int mi = Dfs(v, min(e->val, flow - used));

                 if (mi) {

                     e->val -= mi;

                     e->ops->val += mi;

                     ans += e->cost * mi;

                     used += mi;

                 }

                 if (used == flow) break;

             }

         }

         return used;

     }

     void Work() {

         res = ; ans = ;

         while (Spfa()) {

             vis[t] = true;

             while (vis[t]) {

                 memset(vis, false, sizeof vis);

                 Dfs(s, inf);

             }

         }

     }

 }

 namespace zkw2{

     struct Edge{

         int to, val, cost;

         Edge *next, *ops;

         Edge(int to, int val, int cost, Edge *next): to(to), val(val), cost(cost), next(next){}

     };

     Edge *head[MAXN << ];

     void BuildGraph(int u, int v, int w, int c) {

         head[u] = new Edge(v, w, c, head[u]);

         head[v] = new Edge(u, , -c, head[v]);

         head[u]->ops = head[v]; head[v]->ops = head[u];

     }

     int s, t, ans, res;

     int dis[MAXN << ];

     bool vis[MAXN << ];

     void init() {

         memset(dis, 0x3f, sizeof(dis));

         memset(vis, false, sizeof(vis));

         s = , t = , ans = , res = ;

     }

     bool Spfa() {

         memset(vis, false, sizeof vis);

         memset(dis, 0x3f, sizeof dis);

         deque<int> q;

         q.push_back(s);

         vis[s] = true; dis[s] = ;

         while (!q.empty()) {

             int u = q.front(); q.pop_front(); vis[u] = false;

             for (Edge *e = head[u]; e; e = e->next) {

                 int v = e->to;

                 if (e->val >  && dis[u] + e->cost < dis[v]) {

                     dis[v] = dis[u] + e->cost;

                     if (!vis[v]) {

                         vis[v] = true;

                         if (!q.empty() && dis[v] < dis[q.front()]) q.push_front(v);

                         else q.push_back(v);

                     }

                 }

             }

         }

         return dis[t] < inf;

     }

     int Dfs(int u, int flow) {

         if (u == t) {

             vis[u] = true;

             res += flow;

             return flow;

         }

         int used = ; vis[u] = true;

         for (Edge *e = head[u]; e; e = e->next) {//当前弧就不加了

             int v = e->to;

             if ((!vis[v] || v == t) && e->val && dis[u] + e->cost == dis[v]) {

                 int mi = Dfs(v, min(e->val, flow - used));

                 if (mi) {

                     e->val -= mi;

                     e->ops->val += mi;

                     ans += e->cost * mi;

                     used += mi;

                 }

                 if (used == flow) break;

             }

         }

         return used;

     }

     void Work() {

         res = ; ans = ;

         while (Spfa()) {

             vis[t] = true;

             while (vis[t]) {

                 memset(vis, false, sizeof vis);

                 Dfs(s, inf);

             }

         }

     }

 }

 int a[], b[];

 int val[][];

 int val2[][];

 signed main() {

     read(M);

     read(N);

     zkw::init();

     zkw :: s = ; zkw :: t = M + N + ;

     int s = , t = M + N + ;

     for ( int i = ; i <= M; ++i ) {

         read(a[i]);

         zkw::BuildGraph(s, i, a[i], );

     }

     for ( int i = ; i <= N; ++i ) {

         read(b[i]);

         zkw::BuildGraph(i + M, t, b[i], );

     }

     for ( int i = ; i <= M; ++i ) {

         for ( int j = ; j <= N; ++j ) {

             read(val[i][j]);

             val2[i][j] = -val[i][j];

             zkw::BuildGraph(i, j + M, inf, val[i][j]);

         }

     }

     zkw :: Work();

     cout << zkw::ans << endl;

     zkw2::init();

     zkw2 :: s = ; zkw2 :: t = M + N + ;

     s = , t = M + N + ;

     for ( int i = ; i <= M; ++i ) {

         zkw2::BuildGraph(s, i, a[i], );

     }

     for ( int i = ; i <= N; ++i ) {

         zkw2::BuildGraph(i + M, t, b[i], );

     }

     for ( int i = ; i <= M; ++i ) {

         for ( int j = ; j <= N; ++j ) {

             zkw2::BuildGraph(i, j + M, inf, val2[i][j]);

             //printf("u:%d v:%d val2[i][j]:%d\n",i, j + M, val2[i][j]);

         }

     }

     zkw2::Work();

     cout <<  - zkw2::ans << endl;

     return ;

 }
#include <bits/stdc++.h>
#define dbg(x) cout << #x << "=" << x << endl
using namespace std;
typedef long long LL;
                   
template<class T>inline void read(T &res)
{
    char c;T flag=;
    while((c=getchar())<''||c>'')if(c=='-')flag=-;res=c-'';
    while((c=getchar())>=''&&c<='')res=res*+c-'';res*=flag;
}
const int MAXN = e + ;
const int inf = 0x3f3f3f3f;
int N, M;
namespace zkw{
    struct Edge{
        int to, val, cost;
        Edge *next, *ops;
        Edge(int to, int val, int cost, Edge *next): to(to), val(val), cost(cost), next(next){}
    };
    Edge *head[MAXN << ];
    void BuildGraph(int u, int v, int w, int c) {
        head[u] = new Edge(v, w, c, head[u]);
        head[v] = new Edge(u, , -c, head[v]);
        head[u]->ops = head[v]; head[v]->ops = head[u];
    }
    int s, t, ans, res;
    int dis[MAXN << ];
    bool vis[MAXN << ];
    void init() {
        memset(dis, 0x3f, sizeof(dis));
        memset(vis, false, sizeof(vis));
        s = , t = , ans = , res = ;
    }
    bool Spfa() {
        memset(vis, false, sizeof vis);
        memset(dis, 0x3f, sizeof dis);
        deque<int> q;
        q.push_back(s);
        vis[s] = true; dis[s] = ;
        while (!q.empty()) {
            int u = q.front(); q.pop_front(); vis[u] = false;
            for (Edge *e = head[u]; e; e = e->next) {
                int v = e->to;
                if (e->val >  && dis[u] + e->cost < dis[v]) {
                    dis[v] = dis[u] + e->cost;
                    if (!vis[v]) {
                        vis[v] = true;
                        if (!q.empty() && dis[v] < dis[q.front()]) q.push_front(v);
                        else q.push_back(v);
                    }
                }
            }
        }
        return dis[t] < inf;
    }
    int Dfs(int u, int flow) {
        if (u == t) {
            vis[u] = true;
            res += flow;
            return flow;
        }
        int used = ; vis[u] = true;
        for (Edge *e = head[u]; e; e = e->next) {//当前弧就不加了
            int v = e->to;
            if ((!vis[v] || v == t) && e->val && dis[u] + e->cost == dis[v]) {
                int mi = Dfs(v, min(e->val, flow - used));
                if (mi) {
                    e->val -= mi;
                    e->ops->val += mi;
                    ans += e->cost * mi;
                    used += mi;
                }
                if (used == flow) break;
            }
        }
        return used;
    }
    void Work() {
        res = ; ans = ;
        while (Spfa()) {
            vis[t] = true;
            while (vis[t]) {
                memset(vis, false, sizeof vis);
                Dfs(s, inf);
            }
        }
    }
}
namespace zkw2{
    struct Edge{
        int to, val, cost;
        Edge *next, *ops;
        Edge(int to, int val, int cost, Edge *next): to(to), val(val), cost(cost), next(next){}
    };
    Edge *head[MAXN << ];
    void BuildGraph(int u, int v, int w, int c) {
        head[u] = new Edge(v, w, c, head[u]);
        head[v] = new Edge(u, , -c, head[v]);
        head[u]->ops = head[v]; head[v]->ops = head[u];
    }
    int s, t, ans, res;
    int dis[MAXN << ];
    bool vis[MAXN << ];
    void init() {
        memset(dis, 0x3f, sizeof(dis));
        memset(vis, false, sizeof(vis));
        s = , t = , ans = , res = ;
    }
    bool Spfa() {
        memset(vis, false, sizeof vis);
        memset(dis, 0x3f, sizeof dis);
        deque<int> q;
        q.push_back(s);
        vis[s] = true; dis[s] = ;
        while (!q.empty()) {
            int u = q.front(); q.pop_front(); vis[u] = false;
            for (Edge *e = head[u]; e; e = e->next) {
                int v = e->to;
                if (e->val >  && dis[u] + e->cost < dis[v]) {
                    dis[v] = dis[u] + e->cost;
                    if (!vis[v]) {
                        vis[v] = true;
                        if (!q.empty() && dis[v] < dis[q.front()]) q.push_front(v);
                        else q.push_back(v);
                    }
                }
            }
        }
        return dis[t] < inf;
    }
    int Dfs(int u, int flow) {
        if (u == t) {
            vis[u] = true;
            res += flow;
            return flow;
        }
        int used = ; vis[u] = true;
        for (Edge *e = head[u]; e; e = e->next) {//当前弧就不加了
            int v = e->to;
            if ((!vis[v] || v == t) && e->val && dis[u] + e->cost == dis[v]) {
                int mi = Dfs(v, min(e->val, flow - used));
                if (mi) {
                    e->val -= mi;
                    e->ops->val += mi;
                    ans += e->cost * mi;
                    used += mi;
                }
                if (used == flow) break;
            }
        }
        return used;
    }
    void Work() {
        res = ; ans = ;
        while (Spfa()) {
            vis[t] = true;
            while (vis[t]) {
                memset(vis, false, sizeof vis);
                Dfs(s, inf);
            }
        }
    }
}
int a[], b[];
int val[][];
int val2[][];
signed main() {
    read(M);
    read(N);
    zkw::init();
    zkw :: s = ; zkw :: t = M + N + ;
    int s = , t = M + N + ;
    for ( int i = ; i <= M; ++i ) {
        read(a[i]);
        zkw::BuildGraph(s, i, a[i], );
    }
    for ( int i = ; i <= N; ++i ) {
        read(b[i]);
        zkw::BuildGraph(i + M, t, b[i], );
    }
    for ( int i = ; i <= M; ++i ) {
        for ( int j = ; j <= N; ++j ) {
            read(val[i][j]);
            val2[i][j] = -val[i][j];
            zkw::BuildGraph(i, j + M, inf, val[i][j]);
        }
    }
    zkw :: Work();
    cout << zkw::ans << endl;
    zkw2::init();
    zkw2 :: s = ; zkw2 :: t = M + N + ;
    s = , t = M + N + ;
    for ( int i = ; i <= M; ++i ) {
        zkw2::BuildGraph(s, i, a[i], );
    }
    for ( int i = ; i <= N; ++i ) {
        zkw2::BuildGraph(i + M, t, b[i], );
    }
    for ( int i = ; i <= M; ++i ) {
        for ( int j = ; j <= N; ++j ) {
            zkw2::BuildGraph(i, j + M, inf, val2[i][j]);
            //printf("u:%d v:%d val2[i][j]:%d\n",i, j + M, val2[i][j]);
        }
    }
    zkw2::Work();
    cout <<  - zkw2::ans << endl;
    return ;
}

P4015 运输问题【zkw费用流】的更多相关文章

  1. 洛谷P4015 运输问题（费用流）

    传送门 源点向仓库连费用$0$,流量为储量的边,商店向汇点连费用$0$,流量为需求的边,然后仓库向商店连流量$inf$,费用对应的边,跑个费用流即可 //minamoto #include<io ...

  2. zkw费用流+当前弧优化

    zkw费用流+当前弧优化 var o,v:..] of boolean; f,s,d,dis:..] of longint; next,p,c,w:..] of longint; i,j,k,l,y, ...

  3. 学习了ZKW费用流

    所谓ZKW费用流,其实就是Dinic. 若干年前有一个人发明了最小增广路算法,每次用BFS找一条增广路,时间O(nm^2) 然后被DinicD飞了:我们为什么不可以在长度不变时多路增广呢?时间O(n^ ...

  4. zkw费用流

    期末结束,竞赛生活继续开始,先怒刷完寒假作业再说 至于期末考试,数学跪惨,各种哦智障错,还有我初中常用的建系大法居然被自己抛至脑后,看来学的还是不扎实,以后数学要老老实实学.物理被永哥黑了两分,然后很 ...

  5. 【zkw费用流】[网络流24题]餐巾计划问题

    题目描述 一个餐厅在相继的N天里,第i天需要Ri块餐巾(i=l,2,-,N).餐厅可以从三种途径获得餐巾. (1)购买新的餐巾,每块需p分: (2)把用过的餐巾送到快洗部,洗一块需m天,费用需f分(f ...

  6. CSU 1948: 超级管理员(普通费用流&&zkw费用流)

    Description 长者对小明施加了膜法,使得小明每天起床就像马丁的早晨一样. 今天小明早上醒来发现自己成了一位仓管员.仓库可以被描述为一个n × m的网格,在每个网格上有几个箱子(可能没有).为 ...

  7. BZOJ2673 [Wf2011]Chips Challenge 费用流 zkw费用流 网络流

    https://darkbzoj.cf/problem/2673 有一个芯片,芯片上有N*N(1≤N≤40)个插槽,可以在里面装零件. 有些插槽不能装零件,有些插槽必须装零件,剩下的插槽随意. 要求装 ...

  8. 图论-zkw费用流

    图论-zkw费用流 模板 这是一个求最小费用最大流的算法,因为发明者是神仙zkw,所以叫zkw费用流(就是zkw线段树那个zkw).有些时候比EK快,有些时候慢一些,没有比普通费用流算法更难,所以学z ...

  9. zkw费用流 学习笔记

    分析 记\(D_i\)为从\(S\)出发到\(i\)的最短路 最短路算法保证, 算法结束时 对于任意存在弧\((i,j)\)满足\(D_i + c_{ij}\ge D_j\) ① 且对于每个 \(j\ ...

随机推荐

  1. SpringCloud之Hystrix服务降级入门全攻略

    理论知识 Hystrix是什么? Hystrix是由Netflix开源的一个服务隔离组件,通过服务隔离来避免由于依赖延迟.异常,引起资源耗尽导致系统不可用的解决方案.这说的有点儿太官方了,它的功能主要 ...

  2. Java第一节课动手动脑

    在第一节课的动手动脑中,主要解决四则运算问题. 首先第一个是出30道四则运算题目,在100以内.这个问题需要控制随机数生成的范围和结果的范围在100以内就可以. 第一次改进是3点:一为避免重复,二为定 ...

  3. SQL的模糊查询（转载）

    本文由转载而来: 原文地址链接:http://www.cnblogs.com/GT_Andy/archive/2009/12/25/1921914.html 在进行数据库查询时,有完整查询和模糊查询之 ...

  4. 一段很简单的PHP代码，用于手机拨号

    <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title> ...

  5. 【Weiss】【第03章】练习3.7：有序多项式相乘

    [练习3.7] 编写一个函数将两个多项式相乘,用一个链表实现.你必须保证输出的多项式按幂次排列,并且任意幂次最多只有一项. a.给出以O(M2N2)时间求解该问题的算法. b.写一个以O(M2N)时间 ...

  6. 【Weiss】【第03章】链表例程

    这种基础例程,如之前所提,会有一个实现和一个简单的测试代码. 链表其实没什么可说的,其实包括后面的栈和队列也没什么可说的,直接放代码吧. 下面这个是测试代码 #include <iostream ...

  7. 【分布式锁】04-使用Redisson实现ReadWriteLock原理

    前言 关于读写锁,大家应该都了解JDK中的ReadWriteLock, 当然Redisson也有读写锁的实现. 所谓读写锁,就是多个客户端同时加读锁,是不会互斥的,多个客户端可以同时加这个读锁,读锁和 ...

  8. 3.python正则匹配不到内容时消耗大量内存

    遇到问题:正常情况获取的网页源码可以通过正则表达式快速匹配到内容,,但是如果出现问题,没有匹配到的内容,正则就会一直回溯,导致内存激增,一直循坏查找. 解决思路:  一.如果能够有特殊内容可以标记,满 ...

  9. xargs命令_Linux xargs命令：一个给其他命令传递参数的过滤器

    本文要为大家介绍的命令是 xargs,我们把它称为护花使者,因为它总是乐于协助其他的命令来完成一些事情.下面一起来看看它是如何护花的. xargs 是 execute arguments 的缩写,它的 ...

  10. python基础知识8——常见内置模块

    Python之路-python(常用模块学习) 模块介绍 time &datetime模块 random os sys shutil shelve xml处理 yaml处理 configpar ...