最大流求最大权闭合图

参考论文： 算法合集之《最小割模型在信息学竞赛中的应用》
有两道题都跟这个论文有关。

poj2987

链接：http://poj.org/problem?id=2987
题意：裁员，如果要开除这个员工那么这个员工的下属也要被开除，给出每个员工的贡献值和从属关系，求最小的裁员数和最大的贡献值。
解法：
求最大权闭合图，闭合图就是图中每个点的后续都在这个图中，求出点的权值之和最大的这样的图。
论文中有专门讲这个，有心去的可以看一下。
最大权闭合图求法：
1.构造网络流，设置一个源点S，从S到将所有点权为正的点连一条边，容量为点权。
2.设置一个汇点T，将所有点权为负的点到T都连一条边，容量为点权的相反数。
3.将原来所有的边的容量都设置为INF
4.求解最小割，最大权=正权值之和-最小割权值
5.残余网络中的点的个数即为裁员个数。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
#include <queue>
using namespace std;
#define M 10009
typedef long long ll;
typedef struct edge
{
    int to;
    ll cap;
    int rev;
};
const ll INF = 0x3f3f3f3f3f3f3f3f;
vector<edge> G[M];
int w[M];
int n,m,s,t;
int acount;
ll sum_w;
int level[M],iter[M];
bool vis[M];
void init()
{
    memset(vis,false,sizeof(vis));
    for(int i = 0;i <= n;i++) G[i].clear();
    sum_w = acount = 0;
}
void add_edge(int u,int v,int cap)
{
    G[u].push_back(edge{v,cap,G[v].size()});
    G[v].push_back(edge{u,0,G[u].size()-1});
}
void bfs()
{
    queue<int> q;
    memset(level,-1,sizeof(level));
    level[s] = 0;
    q.push(s);
    while(!q.empty())
    {
        int v = q.front();
        q.pop();
        for(int i = 0;i < G[v].size();i++)
        {
            edge& e = G[v][i];
            if(e.cap > 0 && level[e.to] < 0)
            {
                level[e.to] = level[v] + 1;
                q.push(e.to);
            }
        }
    }
}
ll dfs(int u,int t,ll f)
{
    if(u == t) return f;
    for(int& i = iter[u]; i < G[u].size();i++)
    {
        edge& e = G[u][i];
        if(e.cap > 0 && level[e.to] > level[u])
        {
            ll d = dfs(e.to,t,min(f,e.cap));
            if(d > 0)
            {
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}
ll max_flow()
{
    ll flow = 0;
    for(;;)
    {
        bfs();
        if(level[t] < 0) return flow;
        memset(iter,0,sizeof(iter));
        ll f;
        while((f = dfs(s,t,INF)) > 0) flow += f;
    }
}
int solve(int u)
{
    acount++;
    vis[u] = true;
    for(int i = 0;i < G[u].size();i++)
    {
        edge& e = G[u][i];
        if(e.cap > 0 && !vis[e.to]) solve(e.to);
    }
}
int main()
{
    while(scanf("%d %d",&n,&m) == 2)
    {
        s = 0;
        t = n+1;
        for(int i = 1;i <= n;i++)
        {
            scanf("%d",&w[i]);
            if(w[i] > 0)
            {
                sum_w += w[i];
                add_edge(s,i,w[i]);
            }
            else add_edge(i,t,-w[i]);
        }
        for(int i = 0;i < m;i++)
        {
            int a,b;
            scanf("%d %d",&a,&b);
            add_edge(a,b,INF);
        }
        ll flow = max_flow();
        solve(s);
        printf("%d %lld\n",acount-1,sum_w - flow);
    }
    return 0;
}