codeforces 546E (最大流)

题目链接：点击这里

题意：第$i$个点本身有$a_i$个士兵，最后要使得第$i$个点有$b_i$个士兵。给出一个图，士兵只能在图上不超过一次边的范围内转移。问能不能达到目标状态。

显然的网络流了。给每个点拆成出点和入点。S到所有的入点，流量是$a_i$；所有的出点到T流量是$b_i$；所有的入点到范围1以内的出点流量是INF；入点到出点流量是INF。开心的跑一次最大流判断是不是慢流即可。方案数在残留网络通过每一个入点寻找有流量的边。

#include <bits/stdc++.h>
using namespace std;
#define maxn 205
#define maxm 40005
#define type int
#define INF 1e7
int n, m;
int s, t;
struct Edge {
    int from, to, next;
    type cap, flow;
    void get (int u, int a, int b, type c, type d) {
        from = u; to = a; next = b; cap = c; flow = d;
    }
}edge[maxm];
int tol;
int head[maxn];
int gap[maxn], dep[maxn], pre[maxn], cur[maxn];

void init () {
    tol = 0;
    memset (head, -1, sizeof head);
}

void add_edge (int u, int v, type w, type rw=0) {
    edge[tol].get(u, v,head[u],w,0);head[u]=tol++;
    edge[tol].get(v, u,head[v],rw,0);head[v]=tol++;
}

type sap (int start, int end, int N) {
    memset (gap, 0, sizeof gap);
    memset (dep, 0, sizeof dep);
    memcpy (cur, head, sizeof head);
    int u = start;
    pre[u] = -1;
    gap[0] = N;
    type ans = 0;
    while (dep[start] < N) {
        if (u == end) {
            type Min = INF;
            for (int i = pre[u]; i != -1; i = pre[edge[i^1].to])
                if (Min > edge[i].cap - edge[i].flow)
                   Min = edge[i].cap-edge[i].flow;
            for (int i = pre[u]; i != -1; i = pre[edge[i^1].to]) {
                edge[i].flow += Min;
                edge[i^1].flow -= Min;
            }
            u = start;
            ans += Min;
            continue;
        }
        bool flag = false;
        int v;
        for (int i = cur[u]; i != -1; i = edge[i].next) {
            v = edge[i].to;
            if (edge[i].cap - edge[i].flow && dep[v]+1 == dep[u]) {
                flag = true;
                cur[u] = pre[v] = i;
                break;
            }
        }
        if (flag) {
            u = v;
            continue;
        }
        int Min = N;
        for (int i = head[u]; i != -1; i = edge[i].next)
            if (edge[i].cap - edge[i].flow && dep[edge[i].to] < Min) {
                  Min = dep[edge[i].to];
                  cur[u] = i;
             }
        gap[dep[u]]--;
        if (!gap[dep[u]]) return ans;
        dep[u] = Min+1;
        gap[dep[u]]++;
        if (u != start) u = edge[pre[u]^1].to;
    }
    return ans;
}

int a[maxn], b[maxn];
int g[maxn][maxn];

int main () {
    cin >> n >> m;
    init ();
    int N;
    s = 0, t = 2*n+1, N = t+1;
    int sum1 = 0;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        sum1 += a[i];
        add_edge (s, i, a[i]);
        add_edge (i, i+n, INF);
    }
    int sum = 0;
    for (int i = 1; i <= n; i++) {
        cin >> b[i];
        add_edge (i+n, t, b[i]);
        sum += b[i];
    }
    for (int i = 0; i < m; i++) {
        int u, v;
        cin >> u >> v;
        add_edge (u, v+n, INF);
        add_edge (v, u+n, INF);
    }
    if (sum1 != sum) {
        cout << "NO" << endl;
        return 0;
    }
    int ans = sap (s, t, N);
    if (ans != sum) {
        cout << "NO" << endl;
        return 0;
    }
    cout << "YES" << endl;
    memset (g, 0, sizeof g);
    for (int u = 1; u <= n; u++) {
        for (int i = head[u]; i != -1; i = edge[i].next) {
            int v = edge[i].to;
            if (v > n && v <= 2*n && edge[i].flow) {
                g[u][v-n] = edge[i].flow;
            }
        }
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            cout << g[i][j] << (j == n ? '\n' : ' ');
        }
    }
    return 0;
}