POJ2987：Firing——题解

http://poj.org/problem?id=2987

题目大意：

炒掉一个人能够获得b收益（b可以<0），但是炒掉一个人必须得炒掉他的下属（然后继续递归）。

求最大收益和此时最小裁员。

——————————————————————————————

我们需要用到最大权闭合图的知识。

为什么呢？我们把u是v的上司变成u—>v，那么我们要求的就是当前图的最大权闭合图。

那么按照最大权闭合图的知识建立图跑最大流即可。

如何求最大权闭合图：

先在原图中添加s（源点）和t（汇点），原图中的边权全部设为INF，权值为正的点与s连边，权值为点的权值，为负则与t连边，权值为负的点的权值。

答案为原图中权值为正的点的和 - 最小割（最大流）

（以下证明不一定严谨）

然后考虑多少人，我们发现原来减掉的最小割就可以表示成我们没有裁的人的权值，那么没有裁的人必然流满了。

所以我们裁掉的人就是我们最小割没有流满的人，dfs一下即可。

//不开long long见祖宗，十年OI一场空。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<cctype>
using namespace std;
typedef long long ll;
const int INF=;
const int maxn=;
inline int read(){
    int X=,w=;char ch=;
    while(!isdigit(ch)){w|=ch=='-';ch=getchar();}
    while(isdigit(ch))X=(X<<)+(X<<)+(ch^),ch=getchar();
    return w?-X:X;
}
int S,T;
struct node{
    int nxt;
    int to;
    ll w;
}edge[*+maxn*+];
int head[maxn],cnt=-;
void add(int u,int v,int w){
    cnt++;
    edge[cnt].to=v;
    edge[cnt].w=w;
    edge[cnt].nxt=head[u];
    head[u]=cnt;
    return;
}
int lev[maxn],cur[maxn];
bool bfs(int m){
    int dui[m],r=;
    for(int i=;i<=m;i++){
        lev[i]=-;
        cur[i]=head[i];
    }
    dui[]=S,lev[S]=;
    int u,v;
    for(int l=;l<=r;l++){
        u=dui[l];
        for(int e=head[u];e!=-;e=edge[e].nxt){
            v=edge[e].to;
            if(edge[e].w>&&lev[v]==-){
                lev[v]=lev[u]+;
                r++;
                dui[r]=v;
                if(v==T)return ;
            }
        }
    }
    return ;
}
ll dinic(int u,int flow,int m){
    if(u==m)return flow;
    ll res=,delta;
    for(int &e=cur[u];e!=-;e=edge[e].nxt){
        int v=edge[e].to;
        if(edge[e].w>&&lev[u]<lev[v]){
            delta=dinic(v,min(edge[e].w,flow-res),m);
            if(delta>){
                edge[e].w-=delta;
                edge[e^].w+=delta;
                res+=delta;
                if(res==flow)break;
            }
        }
    }
    if(res!=flow)lev[u]=-;
    return res;
}
bool vis[maxn];
int dfs(int u){
    int ans=;
    vis[u]=;
    for(int i=head[u];i!=-;i=edge[i].nxt){
    int v=edge[i].to;
    if(edge[i].w>&&!vis[v]){
        ans+=dfs(v);
    }
    }
    return ans;
}
int main(){
    memset(head,-,sizeof(head));
    int n=read();
    int m=read();
    S=n+;T=n+;
    ll sum=;
    for(int i=;i<=n;i++){
    ll b=read();
    if(b>){
        sum+=b;
        add(S,i,b);
        add(i,S,);
    }else{
        add(i,T,-b);
        add(T,i,);
    }
    }
    for(int i=;i<=m;i++){
    int a=read();
    int b=read();
    add(a,b,INF);
    add(b,a,);
    }
    ll ans=;
    while(bfs(T))ans+=dinic(S,INF,T);
    printf("%d %lld\n",dfs(S)-,sum-ans);
    return ;
}