Destroying The Graph 最小点权集--最小割--最大流

　　　　　　　　　　　　　　　　　　　　　　　　　　Destroying The Graph

构图思路: 

1.将所有顶点v拆成两个点， v1,v2

2.源点S与v1连边，容量为 W-

3.v2与汇点连边，容量为 W+

4.对图中原边( a, b ), 连边 (a1,b2)，容量为正无穷大

则该图的最小割(最大流)即为最小花费。

简单证明： 根据ST割集的定义，将顶点分成两个点集。所以对于原图中的边(a,b),转换成 S->a1->b2->T. 则此时路径必定存在

一条割边，因为a1->b2为无穷大，所以割边必定是 S->a1 or b2->T,  若为前者则意味着删除a顶点的W-，后者则是b顶点的W+.

所以该图最小割即为最小花费。

计算方案： 对于构图后跑一次最大流，然后对于残留网络进行处理，首先从源点S出发，标记所有能访问到的顶点，这些顶点即为S割点集中

的顶点。 其他则为T集合中顶点， 然后从所有边中筛选出( A属于S,B属于T,且（A,B)容量为0 )的边，即为割边。因为我们的W+/W-边都只有一条，

且都分开了。比较容易处理。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <sstream>
#include <iomanip>
using namespace std;
typedef long long LL;
const int INF = 0x4fffffff;
const double EXP = 1e-5;
const int MS = 2005;
const int SIZE = 100005;

struct edge
{
      int v,c,f,other;
}e;

vector<edge> edges[MS];     //  邻接表
vector<int> level_edges[MS];
vector<int> ans;

int que[MS],level[MS],pre[MS],hash[MS],d[MS];
int s,t;

void add(int u,int v,int c)
{
      e.v=v;
      e.c=c;
      e.f=0;
      e.other=edges[v].size();
      edges[u].push_back(e);

      e.v=u;             //  reverse edge
      e.c=0;
      e.f=0;
      e.other=edges[u].size()-1;
      edges[v].push_back(e);
}

bool BFS()         // bfs 构建层次网络
{
      int head=0,tail=0,cur,i;
      for(int i=s;i<=t;i++)
            level_edges[i].clear();
      memset(level,0xff,sizeof(level));
      que[tail++]=s;
      level[s]=0;
      while(head<tail)
      {
            cur=que[head++];
            for(i=0;i<edges[cur].size();i++)
            {
                  e=edges[cur][i];
                  if(e.c>e.f)
                  {
                        if(level[e.v]==-1)
                        {
                              que[tail++]=e.v;
                              level[e.v]=level[cur]+1;
                        }
                        if(level[e.v]==level[cur]+1)
                        {
                              level_edges[cur].push_back(i);
                        }
                  }
            }
      }
      if(level[t]!=-1)
            return 1;
      else
            return 0;
}


int dinic()
{
      int i,j,ans=0,len;
      while(BFS())
      {
            memset(hash,0,sizeof(hash));
            while(!hash[s])
            {
                  d[s]=INF;
                  pre[s]=-1;
                  for(i=s;i!=t&&i!=-1;i=j)
                  {
                        len=level_edges[i].size();
                        while(len&&hash[ edges[i][level_edges[i][len-1]].v] )
                        {
                              level_edges[i].pop_back();
                              len--;
                        }
                        if(!len)
                        {
                              hash[i]=1;
                              j=pre[i];
                              continue;
                        }
                        j=edges[i][level_edges[i][len-1]].v;
                        pre[j]=i;
                        d[j]=min(d[i],edges[i][level_edges[i][len-1]].c-edges[i][level_edges[i][len-1]].f);
                  }
                  if(i==t)
                  {
                        ans+=d[t];
                        while(i!=s)
                        {
                              j=pre[i];
                              len=level_edges[j][level_edges[j].size()-1];
                              edges[j][len].f+=d[t];
                              if(edges[j][len].f==edges[j][len].c)
                                    level_edges[j].pop_back();
                              edges[i][edges[j][len].other].f-=d[t];
                              i=j;
                        }
                  }
            }
      }
      return ans;
}

void DFS(int u)
{
      int i,k;
      hash[u]=1;
      for(i=0;i<edges[u].size();i++)
      {
            k=edges[u][i].v;
            if(!hash[k]&&edges[u][i].c-edges[u][i].f>0)
                  DFS(k);
      }
}

int main()
{
      int n,m,i,j,k,N,tmp,answer;
      while(scanf("%d%d",&n,&m)!=EOF)
      {
            N=2*n+1;
            s=0;
            t=N;
            for(i=s;i<=t;i++)
                  edges[i].clear();
            for(i=1;i<=n;i++)
            {
                  scanf("%d",&tmp);
                  add(n+i,N,tmp);
            }
            for(i=1;i<=n;i++)
            {
                  scanf("%d",&tmp);
                  add(0,i,tmp);
            }
            for(k=0;k<m;k++)
            {
                  scanf("%d%d",&i,&j);
                  add(i,n+j,INF);
            }
            answer=dinic();
            memset(hash,0,sizeof(hash));
            DFS(0);
            ans.clear();
            for(i=1;i<=n;i++)
            {
                  if(!hash[i])
                        ans.push_back(i);
                  if(hash[n+i])
                        ans.push_back(n+i);
            }
            printf("%d
%d
",answer,ans.size());
            for(i=0;i<ans.size();i++)
            {
                  if(ans[i]<=n)
                        printf("%d -
",ans[i]);
                  else
                        printf("%d +
",ans[i]-n);
            }
      }
      return 0;
}