poj 2987 Firing 最大权闭合图

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

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?

题目描述：公司解雇员工，每个员工有一个权值，可正可负可为零（对公司而言等同于员工对公司的贡献力）。然后给出一些员工上下级的关系，如果解雇一个员工（比如经理主管之类的），那么他手下的员工都会被解雇，问对公司获利最大的解雇计划以及解雇员工人数。

算法分析：每个员工看作一个点，新增源点from和汇点to，from连边权值为正的点，边权为该权值；to连边权值为负的点，边权为权值的绝对值；员工之间的上下级也连边，边权为无穷大。最后最大权闭合图=权值为正的点的权值的和-最小割。

最大权闭合图参考资料：

胡伯涛 《最小割模型在信息学竞赛中的应用》

大牛博客：【网络流】最大权闭合图

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<cmath>
 #include<algorithm>
 #include<vector>
 #include<queue>
 #define inf 0x7fffffff
 using namespace std;
 typedef long long LL;
 const int maxn=+;
 const int M = +;

 int n,m,from,to;
 struct node
 {
     int v,flow;
     int next;
 }edge[M*];
 int head[maxn],edgenum;

 void add(int u,int v,int flow)
 {
     edge[edgenum].v=v ;edge[edgenum].flow=flow ;
     edge[edgenum].next=head[u] ;head[u]=edgenum++ ;

     edge[edgenum].v=u ;edge[edgenum].flow= ;
     edge[edgenum].next=head[v] ;head[v]=edgenum++ ;
 }

 int d[maxn];
 int bfs()
 {
     memset(d,,sizeof(d));
     d[from]=;
     queue<int> Q;
     Q.push(from);
     while (!Q.empty())
     {
         int u=Q.front() ;Q.pop() ;
         for (int i=head[u] ;i!=- ;i=edge[i].next)
         {
             int v=edge[i].v;
             if (!d[v] && edge[i].flow)
             {
                 d[v]=d[u]+;
                 Q.push(v);
                 if (v==to) return ;
             }
         }
     }
     return ;
 }

 int dfs(int u,int flow)
 {
     if (u==to || flow==) return flow;
     int cap=flow;
     for (int i=head[u] ;i!=- ;i=edge[i].next)
     {
         int v=edge[i].v;
         if (d[v]==d[u]+ && edge[i].flow)
         {
             int x=dfs(v,min(edge[i].flow,cap));
             edge[i].flow -= x;
             edge[i^].flow += x;
             cap -= x;
             if (cap==) return flow;
         }
     }
     return flow-cap;
 }

 LL dinic()
 {
     LL ans=;
     while (bfs()) ans += dfs(from,inf);
     return ans;
 }

 int vis[maxn];
 void dfs2(int u)
 {
     if (u==to) return ;
     vis[u]=;
     for (int i=head[u] ;i!=- ;i=edge[i].next)
         if (edge[i].flow> && !vis[edge[i].v ])
             dfs2(edge[i].v);
 }

 int main()
 {
     while (scanf("%d%d",&n,&m)!=EOF)
     {
         memset(head,-,sizeof(head));
         edgenum=;
         from=n+;
         to=from+;
         int a,b;
         LL sum=;
         for (int i= ;i<=n ;i++)
         {
             scanf("%d",&a);
             if (a>) {sum += a ;add(from,i,a) ;}
             else add(i,to,-a);
         }
         for (int i= ;i<m ;i++)
         {
             scanf("%d%d",&a,&b);
             add(a,b,inf);
         }
         sum=sum-dinic();
         memset(vis,,sizeof(vis));
         dfs2(from);
         int ans=;
         for (int i= ;i<=n ;i++) if (vis[i]) ans++;
         printf("%d %I64d\n",ans,sum);
     }
     return ;
 }