POJ 2987 Firing(最大权闭合)

题目大意：给出一张图，要求求出最大权闭合

解题思路：详见刘伯涛算：法合集之《最小割模型在信息学竞赛中的应用》

这里还是解释一下S集合里面的点为什么是要开除的人

首先得到的割肯定是个简单割了，接着来分类讨论一下，有哪些边会被包含在这里面

1.连接源点的边，这里分两种情况

a.如果该边满流了(表示该边是割边，且该点并不在S集中)，就表示收益<=0的了，当收益为负时，肯定是不要开除的好了。当收益为0时，开除和不开除都一样了，不会影响到收益，又因为要开除的人最少，所以选择不开除

b.如果该边没有满流(非割边，属于S集)，表示收益为正的，开除掉几个人可以增加收益，那当然开除掉，而几个人的关系使用容量为无限大的边连接的，所以选择该点，后续的所有点都会被选到的

2.连接汇点的边,这里也分两种情况

a.如果该边满流了(割边，该点属于S集)，那么连接该点的，且连接源点的边就会存在两种情况，一种是所有边都是满流的，那么对应上面的情况a，所以选择不开除。另一种情况是存在有不满流的边，对应上面的情况b

b.如果该边没有满流(非割边，且连接他的所有点到源点的边都是割边，所以该点属于集合T)，就表明连接该点的，且连接到源点的所有边都是满流了，对面上面的第1种情况的第a中情况

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

#define M 1000010
#define N 10010
#define INF 0x3f3f3f3f3f3f3f3f
#define ll long long
struct Edge{
    int u, v, next;
    ll cap, flow;
    Edge() {}
    Edge(int u, int v, ll cap, ll flow, int next): u(u), v(v), cap(cap), flow(flow), next(next) {}
}E[M];

struct Dinic{
    int head
, d
;
    int tot, sink, source;

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

    inline void AddEdge(int u, int v, ll cap) {
        E[tot] = Edge(u, v, cap, 0, head[u]); head[u] = tot++;
        u = u ^ v; v = u ^ v; u = u ^ v;
        E[tot] = Edge(u, v, 0, 0, head[u]); head[u] = tot++;
    }

    inline bool bfs(int s) {
        int u, v;
        memset(d, 0, sizeof(d));
        queue<int> Q;
        Q.push(s);
        d[s] = 1;
        while (!Q.empty()) {
            u = Q.front(); Q.pop();
            if (u == sink) return true;
            for (int i = head[u]; ~i; i = E[i].next) {
                v = E[i].v;
                if (!d[v] && E[i].cap - E[i].flow > 0) {
                    d[v] = d[u] + 1;
                    Q.push(v);
                }
            }
        }
        return false;
    }

    ll dfs(int x, ll a) {
        if (x == sink || a == 0)
            return a;
        ll f, flow = 0;
        for (int i = head[x]; ~i; i = E[i].next) {
            int v = E[i].v;
            if (d[v] == d[x] + 1 && E[i].cap - E[i].flow > 0) {
                f = dfs(v, min(a, E[i].cap - E[i].flow));
                E[i].flow += f;
                E[i^1].flow -= f;
                flow += f;
                a -= f;
                if (!a) break;
            }
        }
        if (flow == 0) d[x] = 0;
        return flow;
    }

    ll Maxflow(int source, int sink) {
        ll flow = 0;
        this->sink = sink;
        while (bfs(source)) flow += dfs(source, INF);
        return flow;
    }
};

Dinic dinic;
#define maxn 5010
int n, m, source, sink, cnt;
ll Sum;
bool vis[maxn];

void dfs(int u) {
    vis[u] = true;
    for (int i = dinic.head[u]; ~i; i = E[i].next) {
        int v = E[i].v;
        if (!vis[v] && E[i].cap - E[i].flow) {
            cnt++;
            dfs(v);
        }
    }
}

void init() {
    source = 0, sink = n + 1, Sum = 0;
    dinic.init();
    ll val;
    for (int i = 1; i <= n; i++) {
        scanf("%lld", &val);
        if (val > 0) {
            dinic.AddEdge(source, i, val);
            Sum += val;
        }
        else dinic.AddEdge(i, sink, -val);
    }
    int u, v;
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        dinic.AddEdge(u, v, INF);
    }
    ll profit = Sum - dinic.Maxflow(source, sink);
    cnt = 0;
    memset(vis, 0, sizeof(vis));
    dfs(source);
    printf("%d %lld\n", cnt, profit);
}

int main() {
    while (scanf("%d%d", &n, &m) != EOF) {
        init();
    }
    return 0;
}