POJ 2987 - Firing 比较完善的最大权闭合子图..维护两个最优值...

                   题意:

                            某公司效益不好要进行裁员...开除每个员工可以得到特定的收益...一些员工可能存在下属..并且一个员工可能存在多个上司...如果开除一个人..他的下属(包括下属的下属..下属下属的下属..)都要被开出...问最大收益是多少..并且最少要开除多少人.

                   题解:

                            因为存在必要关系..并且选择了某点其必要关系的点就必须选..所以该题是一个最大权闭合子图的问题...解决方法是:

                             1、将所有正权的点加起来..记为sum

                             2、超级源点向所有的正权点相连..容量为其权

                             3、所有负权点向超级汇点相连..容量为其权的相反数

                             4、sum-MaxFlow(s,e)就是答案...

                           本题的第二个问题就是要在选择的点权之和最大的时候点数最少..解决的方法也是很常规的..用一个偏移量来维护两个优先级的值..由于点数最多5000个..我是设置了偏移量为6000..保证互不干扰..设某点的权为x...1、当x>0时..超级源点向该点加边,容量为x*6000-1..记录正权点个数的num++

                                                                                      2、当x<=0时..该点向超级汇点加边.容量为-x*6000+1

                           然后跑最大流为F...那么最小点数为(F+num)%6000...最大点权为(F+num)/6000

Program:

#include<iostream>    
#include<algorithm>    
#include<stdio.h>    
#include<string.h>  
#include<time.h> 
#include<map> 
#include<math.h>    
#include<queue>    
#define MAXN 6050 
#define MAXM 800005 
#define oo ((ll)2000000007)*((ll)2000000007)
#define ll long long    
using namespace std;   
struct Dinic              
{              
       struct node            
       {             
             int u,v,next;            
             ll c;
       }edge[MAXM];            
       int ne,head[MAXN],cur[MAXN];
       ll ps[MAXN],dep[MAXN];          
       void initial()            
       {            
             ne=2;            
             memset(head,0,sizeof(head));             
       }  
       void addedge(int u, int v,ll c)            
       {             
             edge[ne].u=u,edge[ne].v=v,edge[ne].c=c,edge[ne].next=head[u];            
             head[u]=ne++;            
             edge[ne].u=v,edge[ne].v=u,edge[ne].c=0,edge[ne].next=head[v];            
             head[v]=ne++;            
       }            
       ll MaxFlow(int s,int t)            
       {                                 
             ll tr,res=0,f,i,j,k,r,top;            
             while(1)            
             {            
                    memset(dep, -1, sizeof(dep));            
                    for(f=dep[ps[0]=s]=0,r=1;f!= r;)            
                       for(i=ps[f++],j=head[i];j;j=edge[j].next)            
                         if(edge[j].c&&dep[k=edge[j].v]==-1)            
                         {            
                               dep[k]=dep[i]+1;            
                               ps[r++]=k;            
                               if(k==t) {  f=r; break;  }            
                         }            
                    if(dep[t]==-1) break;            
                    memcpy(cur,head,sizeof(cur));            
                    i=s,top=0;            
                    while(1)            
                    {            
                         if(i==t)            
                         {            
                               for(tr=oo,k=0;k<top;k++)            
                                  if(edge[ps[k]].c<tr)            
                                     tr=edge[ps[f=k]].c;            
                               for(k=0;k<top;k++)            
                               {            
                                     edge[ps[k]].c-=tr;            
                                     edge[ps[k]^1].c+=tr;            
                               }            
                               i=edge[ps[top=f]].u;            
                               res+= tr;            
                         }            
                         for(j=cur[i];cur[i];j=cur[i]=edge[cur[i]].next)             
                             if(edge[j].c && dep[i]+1==dep[edge[j].v]) break;             
                         if(cur[i])  ps[top++]=cur[i],i=edge[cur[i]].v;             
                         else            
                         {            
                                 if(!top) break;            
                                 dep[i]=-1;            
                                 i=edge[ps[--top]].u;            
                         }            
                   }            
             }            
             return res;            
      }           
}T;  
int main()   
{       
      int m,s,e,i,u,v;
      ll F,sum,x,n,num,M=6000;   
      scanf("%I64d%d",&n,&m);
      T.initial(),sum=0,s=n+1,e=s+1,num=0;
      for (i=1;i<=n;i++) 
      {
              scanf("%I64d",&x);
              if (x>0) sum+=x,T.addedge(s,i,x*M-1),num++;
                  else T.addedge(i,e,-x*M+1);
      }
      while (m--)
      {
              scanf("%d%d",&u,&v);
              T.addedge(u,v,oo);
      }
      F=T.MaxFlow(s,e)+num;
      printf("%I64d %I64d\n",F%M,sum-F/M);
      return 0;  
}