UVa 11082 - Matrix Decompressing（最大流）

链接：

https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=2023

题意：

对于一个R行C列的正整数矩阵（1≤R，C≤20），设Ai为前i行所有元素之和，Bi为前i列所有元素之和。
已知R,C和数组A和B，找一个满足条件的矩阵。矩阵中的元素必须是1～20之间的正整数。输入保证有解。

分析：

首先根据Ai和Bi计算出第i行的元素之和Ai'和第i列的元素之和Bi'。
如果把矩阵里的每个数都减1，则每个Ai'会减少C，而每个Bi'会减少R。
这样一来，每个元素的范围变成了0～19，它的好处很快就能看到。
建立一个二分图，每行对应一个X结点，每列对应一个Y结点，然后增加源点s和汇点t。
对于每个结点Xi，从s到Xi连一条弧，容量为Ai'-C；从Yi到t连一条弧，容量为Bi'-R。
而对于每对结点(Xi,Yj)，从Xi向Yj连一条弧，容量为19。
接下来求s-t的最大流，如果所有s出发和到达t的边都满载，说明问题有解，
结点Xi->Yj的流量就是格子(i,j)减1之后的值。

代码：

 #include <cstdio>
 #include <cstring>
 #include <queue>
 #include <vector>
 using namespace std;
 
 /// 结点下标从0开始，注意maxn
 struct Dinic {
     static const int maxn =  + ;
     static const int INF = 0x3f3f3f3f;
     struct Edge {
         int from, to, cap, flow;
     };
 
     int n, m, s, t; // 结点数，边数（包括反向弧），源点编号和汇点编号
     vector<Edge> edges; // 边表。edges[e]和edges[e^1]互为反向弧
     vector<int> G[maxn]; // 邻接表，G[i][j]表示结点i的第j条边在e数组中的序号
     bool vis[maxn]; // BFS使用
     int d[maxn]; // 从起点到i的距离
     int cur[maxn]; // 当前弧下标
 
     void init(int n) {
         this->n = n;
         edges.clear();
         for(int i = ; i < n; i++) G[i].clear();
     }
     void AddEdge(int from, int to, int cap) {
         edges.push_back((Edge){from, to, cap, });
         edges.push_back((Edge){to, from, , });
         m = edges.size();
         G[from].push_back(m-);
         G[to].push_back(m-);
     }
     bool BFS() {
         memset(vis, , sizeof(vis));
         queue<int> Q;
         Q.push(s);
         vis[s] = ;
         d[s] = ;
         while(!Q.empty()) {
             int x = Q.front();  Q.pop();
             for(int i = ; i < G[x].size(); i++) {
                 Edge& e = edges[G[x][i]];
                 if(!vis[e.to] && e.cap > e.flow) { // 只考虑残量网络中的弧
                     vis[e.to] = ;
                     d[e.to] = d[x] + ;
                     Q.push(e.to);
                 }
             }
         }
         return vis[t];
     }
     int DFS(int x, int a) {
         if(x == t || a == ) return a;
         int flow = , f;
         for(int& i = cur[x]; i < G[x].size(); i++) { // 从上次考虑的弧
             Edge& e = edges[G[x][i]];
             if(d[x]+ == d[e.to] && (f=DFS(e.to, min(a, e.cap-e.flow))) > ) {
                 e.flow += f;
                 edges[G[x][i]^].flow -= f;
                 flow += f;
                 a -= f;
                 if(a == ) break;
             }
         }
         return flow;
     }
     int Maxflow(int s, int t) {
         this->s = s;  this->t = t;
         int flow = ;
         while(BFS()) {
             memset(cur, , sizeof(cur));
             flow += DFS(s, INF);
         }
         return flow;
     }
     vector<int> Mincut() { // 在Maxflow之后调用
         vector<int> ans;
         for(int i = ; i < edges.size(); i++) {
             Edge& e = edges[i];
             if(vis[e.from] && !vis[e.to] && e.cap > ) ans.push_back(i);
         }
         return ans;
     }
 };
 
 const int UP =  + ;
 int id[UP][UP];
 Dinic dc;
 
 int main() {
     int T, R, C;
     scanf("%d", &T);
     for(int cases = ; cases <= T; cases++) {
         scanf("%d%d", &R, &C);
         dc.init(R+C+);
         int start = R+C, finish = R+C+, last = ;
         for(int v, i = ; i < R; i++) {
             scanf("%d", &v);
             dc.AddEdge(start, i, v - last - C);
             last = v;
         }
         last = ;
         for(int v, i = ; i < C; i++) {
             scanf("%d", &v);
             dc.AddEdge(R+i, finish, v - last - R);
             last = v;
         }
         for(int r = ; r < R; r++) {
             for(int c = ; c < C; c++) {
                 dc.AddEdge(r, R+c, );
                 id[r][c] = dc.edges.size() - ;
             }
         }
 
         dc.Maxflow(start, finish);
         printf("Matrix %d\n", cases);
         for(int r = ; r < R; r++) {
             for(int c = ; c < C; c++) {
                 printf("%d ", dc.edges[id[r][c]].flow + );
             }
             printf("\n");
         }
         printf("\n");
     }
     return ;
 }