POJ 2125 Destroying The Graph 最小点权覆盖

题意: 在一个有向图中,如果删掉从别的点引入该店的边,话费为Ai;如果删掉从该店引出的边,话费为Bi。问要想删掉整个图上的边,最小花费为多少?

解题思路:选中的点要包含所有的边,从这点不难想到是最小点权覆盖。

把每个点才拆成两个点Pi和Pi',建c(Pi',T)=Ai,表示删掉引入这个点的边的花费。

建c(S,Pi)=Bi,表示删掉从该点引出的边的花费。

然后对于原图(u,v),建(Pu,Pv')表示u和v至少要选一点，

然后进行一遍最大流即为最小花费。(证明见胡伯涛《最小割模型在信息学竞赛中的应用》)

难点在第二步。要问删掉了哪些点。

因为此图为二分图中的简单图,

割边必定与源点或汇点相邻,所以可转化为求最小割中的割边。(如果不是简单图就不能这么做了)

回想一下最小割的性质,割边把二分图分为包含S和T的N与M两部分,

按残余流量遍历时,S不能遍历到M中的点,

N中的点不能遍历到T。

但是从另个角度讲,

因为此图是简单图,

所以S能遍历到N中的每个点,

M中的每个点都能遍历到T。

所以从S遍历,不能遍历到的点P必被割掉,

从T点按反图遍历,不能遍历到T的P‘也必备割掉。

此题到这也就能完成了。

后来还有个优化,

还是因为此图是简单图,每个点必与而且被S和T中的一个点遍历到,

所以从S遍历一遍就够了,能被S遍历到的必定不能被T遍历到,反之亦然。

贴代码:

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cstdlib>
#include <queue>
#include <stack>
using namespace std;

#define REP(i,n)   for(int i=0;i<(n);++i)
#define FOR(i,l,r) for(int i=(l);i<=(r);++i)
#define DSC(i,r,l) for(int i=(r);i>=(l);--i)
#define N 1000
#define M 20000
#define INF 1e8
int n;
struct
{
    int to,next;
    int c;
}edge[M];
int head[N],level[N],ip;
int que[N];
bool makelevel(int s,int t)
{
    memset(level,0,sizeof(level));
    int iq=0;
    que[iq++]=s;
    level[s]=1;
    int top;
    for(int i=0;i<iq;i++)
    {
        top=que[i];
        if(top==t)  return 1;
        for(int k=head[top];k!=-1;k=edge[k].next)
        {
            if(!level[edge[k].to]&&edge[k].c>0)
            {
                que[iq++]=edge[k].to;
                level[edge[k].to]=level[top]+1;
            }
        }
    }
    return 0;
}
int dfs(int now,int maxf,int t)
{
    if(now==t)  return maxf;
    int  ret=0,c;
    for(int k=head[now];k!=-1;k=edge[k].next)
    {
        if(edge[k].c>0&&level[edge[k].to]==(level[now]+1))
        {
            c=dfs(edge[k].to,min(maxf-ret,edge[k].c),t);
            edge[k].c-=c;
            edge[k^1].c+=c;
            ret+=c;

            if(ret==maxf)   return  ret;
        }
    }
    if(!ret) --level[now];
    return ret;
}
int dinic(int s,int t)
{
    int  ans=0;
    while(makelevel(s,t))   ans+=dfs(s,INF,t);
    return ans;
}
void add(int u,int v,int c,int f)//有向边f为0 ,否则为 c
{
    edge[ip].to=v;edge[ip].c=c;edge[ip].next=head[u];head[u]=ip++;
    edge[ip].to=u;edge[ip].c=f;edge[ip].next=head[v];head[v]=ip++;
}
//在这之前是标准的网络流模型,不用看了
bool flag[N];
void dfs1(int pos)
{
    flag[pos]=1;
    for(int p=head[pos];p!=-1;p=edge[p].next)
    {
        if(edge[p].c && !flag[ edge[p].to ])    dfs1(edge[p].to);
    }
}
int main()
{
    int m,x,y;
    while(cin>>n>>m)
    {
        memset(head,-1,sizeof(head)); ip=0;
        memset(flag,0,sizeof(flag));
        int start=0,end=n+n+1;
        FOR(i,1,n)
        {
            scanf("%d",&x);//建c(Pi',T)=Ai,表示删掉引入这个点的边的花费
            add(i+n,end,x,0);
        }
        FOR(i,1,n)
        {
            scanf("%d",&x);//建c(S,pi)=Bi,表示删掉从这个点引出的边的花费
            add(start,i,x,0);
        }
        REP(i,m)
        {
            scanf("%d%d",&x,&y);
            add(x,y+n,INF,0);//对于原图的(u,v)建(Pu,Pv')
        }
        cout<<dinic(start,end)<<endl;//最小割即为第一问的答案
        dfs1(start);//从S开始遍历一遍就够了
        int ans=0;
        FOR(i,1,n)
        {
            if(flag[i+n]) ans++;//不能被T遍历到的P'
            if(!flag[i])  ans++;//不能被S遍历到的P
        }
        cout<<ans<<endl;
        FOR(i,1,n)
        {
            if(flag[i+n]) printf("%d +\n",i);
            if(!flag[i])  printf("%d -\n",i);
        }
    }
    return 0;
}