UVA 11082 Matrix Decompressing （最大流）

题意：

告诉你一个n*m的矩阵的每一行元素之和 和每一列元素之和，要求还原矩阵，矩阵的每一个元素不超过20。

思路：

没想到这种题竟然是网络流，长见识了：

我们拆成每一行x1，x2，x3，，，xn  和每一列 y1，y2，y3，，，ym

每一行和每一列连边，容量为19， 之所以是19，因为题目要求是1~20， 但流量可以是0，这样的话， 我们算出来是0~20的，不如我们减一，算0~19，在加1，正好是1~20.

然后源点与每一行连边，容量为每一行元素之和减m （因为每个数都减1了）， 每一列 与汇点相连。

这样当满流之后是有解的，答案就是每一行和每一列的流量。

吐槽：

没加特判每一列的范围wa了好几遍，二维数组的负值是循环的。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#define Siz(x) (int)x.size()
using namespace std;
const int maxn = 1000 + 7;
const int inf = 1000000;

struct Edge{
    int from, to, cap, flow;
};

struct Dinic{
    int n, m, s, t;
    vector<Edge>edges;
    vector<int>G[maxn];
    bool vis[maxn];
    int d[maxn];
    int cur[maxn];

    void init(int nn){
        edges.clear();
        for (int i = 0; i < nn; ++i)G[i].clear();
    }

    void AddEdge(int from,int to,int cap){
        edges.push_back((Edge){from,to,cap,0});
        edges.push_back((Edge){to,from,0,0});
        m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool BFS(){
        memset(vis,0,sizeof vis);
        queue<int>Q;
        Q.push(s);
        d[s] = 0;
        vis[s] = 1;
        while(!Q.empty()){
            int x = Q.front(); Q.pop();
            for (int i = 0; i < G[x].size(); ++i){
                Edge& e = edges[G[x][i]];
                if (!vis[e.to] && e.cap > e.flow) {
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int DFS(int x,int a){
        if (x == t || a == 0) return a;
        int flow = 0, f;
        for (int& i = cur[x]; i < G[x].size(); ++i){
            Edge& e = edges[G[x][i]];
            if (d[x] + 1 == d[e.to] && (f = DFS(e.to,min(a,e.cap-e.flow))) > 0){
                e.flow += f;
                edges[G[x][i]^1 ].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 = 0;
        while(BFS()){
            memset(cur,0,sizeof cur);
            flow += DFS(s,inf);
        }
        return flow;
    }

}dic;
int a[30], b[30];
int ans[30][30];
int main(){
    int T, ks = 0;
    scanf("%d",&T);
    while(T--){
        int n,m;
        scanf("%d %d",&n, &m);
        dic.init(n+m+7);
        for (int i = 1; i <= n; ++i) {
            scanf("%d",a+i);
        }
        for (int i = n; i > 1; --i) a[i] -= a[i-1];
        for (int i = 1; i <= m; ++i) {
            scanf("%d",b+i);
        }
        for (int i = m; i > 1; --i) b[i] -= b[i-1];

        for (int i = 1; i <= n; ++i){
            for (int j = 1; j <= m; ++j){
                dic.AddEdge(i,j+n,19);
            }
        }
        for (int i = 1; i <= n; ++i){
            dic.AddEdge(0,i,a[i]-m);
        }
        for (int i = 1; i <= m; ++i){
            dic.AddEdge(i+n,n+m+1,b[i]-n);
        }
        dic.Maxflow(0,n+1+m);
        for (int i = 1; i <= n; ++i){
            for (int j = 0; j < Siz(dic.G[i]); ++j){
                int id=dic.G[i][j];
                Edge& e = dic.edges[id];
                if (e.to-n >= 1 && e.to-n <= m)ans[i][e.to-n] = e.flow + 1; //要特么范围，否则负数会造成循环赋值。
            }
        }
        if (ks++)puts("");
        printf("Matrix %d\n",ks);
        for (int i = 1; i <= n;++i){
            for (int j = 1; j <= m; ++j){
                if (j > 1)printf(" ");
                printf("%d",ans[i][j]);
            }
            putchar('\n');
        }

    }

    return 0;
}
/**

**/