POJ 2987 Firing（最大流最小割の最大权闭合图）

Description

You’ve finally got mad at “the world’s most stupid” employees of yours and decided to do some firings. You’re now simply too mad to give response to questions like “Don’t you think it is an even more stupid decision to have signed them?”, yet calm enough to consider the potential profit and loss from firing a good portion of them. While getting rid of an employee will save your wage and bonus expenditure on him, termination of a contract before expiration costs you funds for compensation. If you fire an employee, you also fire all his underlings and the underlings of his underlings and those underlings’ underlings’ underlings… An employee may serve in several departments and his (direct or indirect) underlings in one department may be his boss in another department. Is your firing plan ready now?

Input

The input starts with two integers n (0 < n ≤ 5000) and m (0 ≤ m ≤ 60000) on the same line. Next follows n + m lines. The first n lines of these give the net profit/loss from firing the i-th employee individually b_i (|b_i| ≤ 10⁷, 1 ≤ i ≤ n). The remaining m lines each contain two integers i and j (1 ≤ i, j ≤ n) meaning the i-th employee has the j-th employee as his direct underling.

Output

Output two integers separated by a single space: the minimum number of employees to fire to achieve the maximum profit, and the maximum profit.

题目大意：有n个点，每个点有一个权值（可能为负数），有m条有向边，求一个闭合子图，要求在权值最大的情况下点最少。

PS：所谓闭合子图，即在一个图中，若选择了x，那么x的所有后继都要选上（如a→b→c→d→e，选了b，就要选c、d、e）。

思路：最大权闭合图的经典建图：源点S到所有正权的点连一条边，容量为权值，从所有负权的点连一条边到汇点T，容量为权值的绝对值。对每一条边(i, j)，连一条边i→j，容量为无穷大。所有正权权值之和减去最大流（最小割）为最大权，从S遍历一遍残量网络，能遍历到的点都为闭合子图中的点，计数即可得到答案。

小证明：在残量网络中，S能遍历到的点都为所选闭合子图，记为V(s)，其余记为V(T)。那么V(S)中任何一个点，它都不会有容量为无穷大的边会指向V(T)中的点，因为若有，这条边要算入最小割，而最小割不可能为无穷大，这就保证了选了点x，x的后继都会被选上。记sum为所有正权权值之和，一个简单割（不割无穷大的边）割掉的与S关联的边的容量和为cut(S)，割掉的与T关联的边的容量和为cut(T)，对于所有选上的点，与源点关联的点的权和应该为sum - cut(S)，cut(S)都是没有选上的点；与汇点关联的选上的点的权和为cut(T)，cut(T)都是选上的点。那么该子图的权和为sum - cut(S) - cut(T)，即sum - (cut(S) + cut(T))，我们需要最大化前面的式子，而sum是固定值，所以需要最小化cut(S) + cut(T)，这个值最小的时候，就是最小割。

关于这样选到的点一定是最少的证明可以看下面的链接，不过简单地说就是：若有多种选择，那么就有一片点，选上它们之后权值总和为0，也就是源点到它们的容量应该是满的，因为我们是在残量网络中遍历，所以它们绝对不会被遍历到。至于下面链接所说的原图是DAG，这个我没看出来哪里说了……不过我们可以把环缩成一个点，不影响证明……

http://hi.baidu.com/dispossessed/item/f75d32161ae2d8573a176e8d

代码（391MS）：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

typedef long long LL;

const int MAXN = 5010;
const int MAXE = 200010;
const LL INF = 0x3fff3fff3fff3fffLL;

struct SAP {
    int head[MAXN], dis[MAXN], gap[MAXN], cur[MAXN], pre[MAXN];
    int to[MAXE], next[MAXE];
    LL flow[MAXE];
    int ecnt, n, st, ed;

    void init() {
        memset(head, 0, sizeof(head));
        ecnt = 2;
    }

    void add_edge(int u, int v, LL c) {
        to[ecnt] = v; flow[ecnt] = c; next[ecnt] = head[u]; head[u] = ecnt++;
        to[ecnt] = u; flow[ecnt] = 0; next[ecnt] = head[v]; head[v] = ecnt++;
        //printf("%d->%d %I64d
", u, v, c);
    }

    void bfs() {
        memset(dis, 0x3f, sizeof(dis));
        queue<int> que; que.push(ed);
        dis[ed] = 0;
        while(!que.empty()) {
            int u = que.front(); que.pop();
            ++gap[dis[u]];
            for(int p = head[u]; p; p = next[p]) {
                int &v = to[p];
                if(flow[p ^ 1] && dis[v] > n) {
                    dis[v] = dis[u] + 1;
                    que.push(v);
                }
            }
        }
    }

    LL Max_flow(int ss, int tt, int nn) {
        st = ss; ed = tt; n = nn;
        LL ans = 0, minFlow = INF;
        for(int i = 0; i <= n; ++i) {
            cur[i] = head[i];
            gap[i] = 0;
        }
        int u = pre[st] = st;
        bfs();
        while(dis[st] < n) {
            bool flag = false;
            for(int &p = cur[u]; p; p = next[p]) {
                int &v = to[p];
                if(flow[p] && dis[u] == dis[v] + 1) {
                    flag = true;
                    minFlow = min(minFlow, flow[p]);
                    pre[v] = u;
                    u = v;
                    if(u == ed) {
                        ans += minFlow;
                        while(u != st) {
                            u = pre[u];
                            flow[cur[u]] -= minFlow;
                            flow[cur[u] ^ 1] += minFlow;
                        }
                        minFlow = INF;
                    }
                    break;
                }
            }
            if(flag) continue;
            int minDis = n - 1;
            for(int p = head[u]; p; p = next[p]) {
                int &v = to[p];
                if(flow[p] && dis[v] < minDis) {
                    minDis = dis[v];
                    cur[u] = p;
                }
            }
            if(--gap[dis[u]] == 0) break;
            ++gap[dis[u] = minDis + 1];
            u = pre[u];
        }
        return ans;
    }

    int cnt_S() {
        memset(dis, 0, sizeof(dis));
        int * vis = dis, ret = 0;
        queue<int> que; que.push(st);
        vis[st] = 1;
        while(!que.empty()) {
            int u = que.front(); que.pop();
            for(int p = head[u]; p; p = next[p]) {
                int &v = to[p];
                if(flow[p] && !vis[v]) {
                    vis[v] = 1;
                    ++ret;
                    que.push(v);
                }
            }
        }
        return ret;
    }
} G;

int main() {
    int n, m, a, b;
    LL x, sum = 0;
    scanf("%d%d", &n, &m);
    int ss = 0, tt = n + 1;
    G.init();
    for(int i = 1; i <= n; ++i) {
        scanf("%I64d", &x);
        if(x > 0) sum += x, G.add_edge(ss, i, x);
        if(x < 0) G.add_edge(i, tt, -x);
    }
    for(int i = 1; i <= m; ++i) {
        scanf("%d%d", &a, &b);
        G.add_edge(a, b, INF);
    }
    LL ans1 = sum - G.Max_flow(ss, tt, tt);
    int ans2 = G.cnt_S();
    printf("%d %I64d
", ans2, ans1);
}