PKU 2987

最大权闭合图。题意我不是很理解，如果按英语原句翻译的话。我觉得输入的正值是亏损，负值是利润。这个可以参考例样，例样解雇了4、5，获得了2的利润。对于第二问如何建图，可以参考其他博客。这个需要画到纸上慢慢理解，不好解释。

对于第一问，仔细分析可以发现：

1.dfs过程不会访问到汇点，否则最大流过程没有完成。

2.如果一条路径上的员工收支平衡，那么这条路径上的所有员工都不会被访问到。

3.用标记数组标记已访问过的点之后，不需要担心最大流建图中反向边的影响。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <memory.h>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <iostream>
#include <sstream>

#define ll __int64

using namespace std;

#define typec ll
#define inf 1000000000
#define E 65010
#define V 5005
struct Dinic {
    struct edge { int x, y, nxt;  typec c; } bf[2 * E];
    int ne, head[V], cur[V], ps[V], dep[V];
    void init(int n) {
        memset(head, 0, (n+1) * sizeof(int));
        ne = 2;
    }
    void addedge(int x, int y, typec c) {
        bf[ne].x = x; bf[ne].y = y; bf[ne].c = c;
        bf[ne].nxt = head[x]; head[x] = ne++;
        bf[ne].x = y; bf[ne].y = x; bf[ne].c = 0;
        bf[ne].nxt = head[y]; head[y] = ne++;
    }
    typec flow(int n, int s, int t) {
        typec tr, res = 0;
        int i, j, k, f, r, top;
        while (true) {
            memset(dep, -1, (n+1) * sizeof(int));
            for (f = dep[ps[0] = s] = 0, r = 1; f != r; )
            for (i = ps[f++], j = head[i]; j; j = bf[j].nxt)
                if (bf[j].c && -1 == dep[k = bf[j].y]) {
                    dep[k] = dep[i] + 1; ps[r++] = k;
                    if (k == t) { f = r; break; }
                }
            if (-1 == dep[t]) break;

            memcpy(cur, head, (n+1) * sizeof(int));
            for (i = s, top = 0; ; ) {
                if (i == t) {
                    for (k = 0, tr = inf; k < top; ++k)
                        if (bf[ps[k]].c < tr)
                            tr = bf[ps[f = k]].c;
                    for (k = 0; k < top; ++k)
                        bf[ps[k]].c -= tr, bf[ps[k]^1].c += tr;
                    res += tr; i = bf[ps[top = f]].x;
                }
                for (j = cur[i]; cur[i]; j = cur[i] = bf[cur[i]].nxt)
                    if(bf[j].c && dep[i]+1 == dep[bf[j].y]) break;
                if(cur[i]) {
                    ps[top++] = cur[i];
                    i = bf[cur[i]].y;
                } else {
                    if(0 == top) break;
                    dep[i] = -1; i = bf[ps[--top]].x;
                }
            }
        }
        return res;
    }
} D;

bool vis[5005];

int dfs(int x) {
    int ret = 0;
    vis[x] = 1;
    for (int p = D.head[x]; p != 0; p = D.bf[p].nxt) {
        if (!vis[D.bf[p].y] && D.bf[p].c > 0) {
            ret++;
            ret += dfs(D.bf[p].y);
        }
    }
    return ret;
}

int main() {
    int n, m, x, y;
    ll v, sum;
    while (scanf("%d %d", &n, &m) != EOF) {
        D.init(n + 2);
        sum = 0;
        for (int i = 1; i <= n; i++) {
            scanf("%I64d", &v);
            if (v > 0) D.addedge(0, i, v), sum += v;
            else if (v < 0) D.addedge(i, n+1, -v);
        }
        for (int i = 0; i < m; i++) {
            scanf("%d %d", &x, &y);
            D.addedge(x, y, inf);
        }
        sum -= D.flow(n + 2, 0, n + 1);
        memset(vis, 0, n + 2);
        printf("%d %I64d\n", dfs(0), sum);
    }
    return 0;
}