POJ 2987

题目链接：http://poj.org/problem?id=2987

Time Limit: 5000MS Memory Limit: 131072K

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.

Sample Input

5 5
8
-9
-20
12
-10
1 2
2 5
1 4
3 4
4 5

Sample Output

2 2

Hint

As of the situation described by the sample input, firing employees 4 and 5 will produce a net profit of 2, which is maximum.

题意：

题目给出N个人，M个直属关系；

N个人每个人都有一个“解雇收益值”，代表公司解雇这个人收益为多少（为负就代表损失）；

M个直属关系：(u, v)代表了，解雇u则必须解雇v；

求公司最少解雇几个人之后，可获得最大收益，为多少；

题解：

显然解雇的人满足闭合图关系，而受益最大则是要求最大点权，故本题就是一个最大权闭合子图；

参考http://www.cnblogs.com/dilthey/p/7565206.html即可。

当然，怎么求出被炒的人呢？

在跑完最大流后，残量网络中超级源点s到与其直接相连的点中：

　　如果这条边不满流，就属于图S（分割后的两个图中包含超级源点s的那个图），则是属于被解雇的人，就标记；

　　如果这条边满流，就属于割集，则这条边的终点不是解雇的人；

然后剩下的，由于图S中，除了与s相连的边权值不为INF外，其他必然为INF，必然不满流，而如果走到了连接t的边，又会变成满流，就会的停下来；

所以只要按着满流与否的条件，DFS下去，不断标记不满流边的终点即可。

AC代码：

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#define MAXN 5005
#define MAXM 60005
#define INF 0x3f3f3f3f
typedef long long ll;
using namespace std;
int n,m;
ll sum;
int cnt;
struct Edge{
    int u,v;
    ll c,f;
};
struct Dinic
{
    int s,t;
    vector<Edge> E;
    vector<int> G[MAXN];
    bool vis[MAXN];
    int lev[MAXN];
    int cur[MAXN];
    void init(int l,int r)
    {
        E.clear();
        for(int i=l;i<=r;i++) G[i].clear();
    }
    void addedge(int from,int to,ll cap)
    {
        E.push_back((Edge){from,to,cap,0});
        E.push_back((Edge){to,from,0,0});
        int m=E.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }
    bool bfs()
    {
        memset(vis,0,sizeof(vis));
        queue<int> q;
        q.push(s);
        lev[s]=0;
        vis[s]=1;
        while(!q.empty())
        {
            int now=q.front(); q.pop();
            for(int i=0,_size=G[now].size();i<_size;i++)
            {
                Edge edge=E[G[now][i]];
                int nex=edge.v;
                if(!vis[nex] && edge.c>edge.f)
                {
                    lev[nex]=lev[now]+1;
                    q.push(nex);
                    vis[nex]=1;
                }
            }
        }
        return vis[t];
    }
    ll dfs(int now,ll aug)
    {
        if(now==t || aug==0) return aug;
        ll flow=0,f;
        for(int& i=cur[now],_size=G[now].size();i<_size;i++)
        {
            Edge& edge=E[G[now][i]];
            int nex=edge.v;
            if(lev[now]+1 == lev[nex] && (f=dfs(nex,min(aug,edge.c-edge.f)))>0)
            {
                edge.f+=f;
                E[G[now][i]^1].f-=f;
                flow+=f;
                aug-=f;
                if(aug==0) break;
            }
        }
        return flow;
    }
    ll maxflow()
    {
        ll flow=0;
        while(bfs())
        {
            memset(cur,0,sizeof(cur));
            flow+=dfs(s,INF);
        }
        return flow;
    }
}dinic;

bool vis[MAXN];
void dfs(int u)
{
    for(int i=0,_size=dinic.G[u].size();i<_size;i++)
    {
        Edge& e=dinic.E[dinic.G[u][i]];
        if(!vis[e.v] && e.c>e.f)
        {
            vis[e.v]=1;
            dfs(e.v);
        }
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    sum=0;
    dinic.init(0,n+1);
    dinic.s=0, dinic.t=n+1;
    for(int i=1,w;i<=n;i++)
    {
        scanf("%d",&w);
        if(w>0)
        {
            sum+=(ll)w;
            dinic.addedge(dinic.s,i,w);
        }
        else if(w<0) dinic.addedge(i,dinic.t,-w);
    }
    for(int i=1,u,v;i<=m;i++)
    {
        scanf("%d%d",&u,&v);
        dinic.addedge(u,v,INF);
    }
        //建图完毕
    ll max_flow=dinic.maxflow();
        //计算出最大流，同时得到残存网络
        
    memset(vis,0,sizeof(vis));
    dfs(dinic.s);//遍历残存网络，找出被解雇的人
    cnt=0;
    for(int i=1;i<=n;i++) if(vis[i]) cnt++;

    printf("%d %I64d
",cnt,sum-max_flow);
}