hdu 3061 Battle【最大权闭包------最小割最大流Dinic】

Battle

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1187    Accepted Submission(s): 564

Problem Description

由于小白同学近期习武十分刻苦，很快被晋升为天策军的统帅。而他上任的第一天，就面对了一场极其困难的战斗：
据侦查兵回报，前方共有N座城池，考虑到地势原因，最终得到一个结论：攻占某些城池之前必须攻占另外一些城池。
事实上，可以把地图看做是一张拓扑图，而攻占某个城池，就意味着必须先攻占它的所有前驱结点。
小白还做了一份调查，得到了攻占每个城池会对他的兵力产生多少消耗（当然也可能会得到增长，因为每攻占一个城池，便可以整顿军队，扩充兵力，天策军的兵力十分庞大，如果不考虑收益，他们可以攻取所有的城池）。
现在请你帮小白统帅做一份战斗计划，挑选攻打哪些城市，使得天策军在战斗过后军容最为壮大。

 

 

Input

首先输入一个N 代表有N个城池（1<= n <= 500）
接着输入一个M，代表城池和城池之间的拓扑关系数。
接着输入N个数字 代表从1 到 N 编号城池的战斗消耗（负数代表将要消耗天策军兵力，正数表示天策军可以获得相应的战斗收益）
最后M行 每行2个数字 a，b，代表相应城池的编号。
表示攻占b之后才可以攻占a；

 

 

Output

天策军最大能获得多少战斗收益

 

 

Sample Input

5 5

8

-8

-10

12

-10

 

1 2

2 5

1 4

3 4

4 5

 

 

Sample Output

2

 

 

Source

2009 Multi-University Training Contest 16 - Host by NIT

 

思路：

1、经典的最大权闭包模型，ans=sum-maxflow------------->ans=所有可能获得的利润和-最小割/最大流

2、建图方式如下：

①建立源点S，连入各个权值为正的点，权值设定为其权值，表示这个点可以赚到的利润值。

②建立汇点T，将各个权值为负的点连入汇点，权值设定为其负权值，表示这个点攻占需要花费的价值。

③将各条有向边连入图中，权值设定为INF.

3、如此建图为何能够保证一个点一定攻占在那些个需要建立的点之后呢？我们可以考虑这样一种情况：

①如果单单建立的是这样一个图：

那么其最小割/最大流=7，ans=15-7=8；很容易理解。

②那么如果点1的攻占，需要点2,3,4的攻占才能攻占1的情况：

很明显，其当S------>1----------->2-------->T这条流跑完了之后，S----------->1的剩余流还需要跑3和4的流，其最小割为7+2+3=12；那么ans=15-12=3；显然可以满足拓扑关系约束下的条件的情况。

③那么也不难理解，如果上图中的2、3、4需要攻占的累加和大于了15，那么15就变成了最小割，那么ans=15-15=0；

4、建好了图之后跑最大流即可，得到的值就是最小割的值，那么ans=sum-maxflow。

Ac代码：

#include<stdio.h>
#include<string.h>
#include<queue>
#include<vector>
using namespace std;
struct node2
{
    int u;
    int num;
}a[5000],now,nex;
struct node
{
    int from;
    int to;
    int w;
    int next;
}e[1200000];
int val[5000];
int head[5000];
int divv[5000];
int cur[5000];
int n,m,ss,tt,cont;
void add(int from,int to,int w)
{
    e[cont].to=to;
    e[cont].w=w;
    e[cont].next=head[from];
    head[from]=cont++;
}
int makedivv()
{
    queue<int >s;
    memset(divv,0,sizeof(divv));
    divv[ss]=1;
    s.push(ss);
    while(!s.empty())
    {
        int u=s.front();
        if(u==tt)return 1;
        s.pop();
        for(int i=head[u];i!=-1;i=e[i].next)
        {
            int v=e[i].to;
            int w=e[i].w;
            if(w&&divv[v]==0)
            {
                divv[v]=divv[u]+1;
                s.push(v);
            }
        }
    }
    return 0;
}
int Dfs(int u,int maxflow,int tt)
{
    if(u==tt)return maxflow;
    int ret=0;
    for(int &i=cur[u];i!=-1;i=e[i].next)
    {
        int v=e[i].to;
        int w=e[i].w;
        if(w&&divv[v]==divv[u]+1)
        {
            int f=Dfs(v,min(maxflow-ret,w),tt);
            e[i].w-=f;
            e[i^1].w+=f;
            ret+=f;
            if(ret==maxflow)return ret;
        }
    }
    return ret;
}
void Dinic()
{
    int ans=0;
    while(makedivv()==1)
    {
        memcpy(cur,head,sizeof(head));
        ans+=Dfs(ss,0x3f3f3f3f,tt);
    }
    int sum=0;
    for(int i=1;i<=n;i++)
    {
        if(val[i]>=0)sum+=val[i];
    }
    printf("%d\n",sum-ans);
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        cont=0;
        memset(head,-1,sizeof(head));
        ss=n+1;
        tt=n+2;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&val[i]);
            if(val[i]>0)
            {
                add(ss,i,val[i]);
                add(i,ss,0);
            }
            else
            {
                add(i,tt,-val[i]);
                add(tt,i,val[i]);
            }
        }
        for(int i=0;i<m;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            add(x,y,0x3f3f3f3f);
            add(y,x,0);
        }
        Dinic();
    }
}