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 = 50 + 5;
    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 = 0; i < n; 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);
        vis[s] = 1;
        d[s] = 0;
        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 == 0) 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;
    }
    vector<int> Mincut() { // 在Maxflow之后调用
        vector<int> ans;
        for(int i = 0; i < edges.size(); i++) {
            Edge& e = edges[i];
            if(vis[e.from] && !vis[e.to] && e.cap > 0) ans.push_back(i);
        }
        return ans;
    }
};

const int UP = 20 + 5;
int id[UP][UP];
Dinic dc;

int main() {
    int T, R, C;
    scanf("%d", &T);
    for(int cases = 1; cases <= T; cases++) {
        scanf("%d%d", &R, &C);
        dc.init(R+C+2);
        int start = R+C, finish = R+C+1, last = 0;
        for(int v, i = 0; i < R; i++) {
            scanf("%d", &v);
            dc.AddEdge(start, i, v - last - C);
            last = v;
        }
        last = 0;
        for(int v, i = 0; i < C; i++) {
            scanf("%d", &v);
            dc.AddEdge(R+i, finish, v - last - R);
            last = v;
        }
        for(int r = 0; r < R; r++) {
            for(int c = 0; c < C; c++) {
                dc.AddEdge(r, R+c, 19);
                id[r][c] = dc.edges.size() - 2;
            }
        }

        dc.Maxflow(start, finish);
        printf("Matrix %d\n", cases);
        for(int r = 0; r < R; r++) {
            for(int c = 0; c < C; c++) {
                printf("%d ", dc.edges[id[r][c]].flow + 1);
            }
            printf("\n");
        }
        printf("\n");
    }
    return 0;
}