hdu4289 Control 最大流最小割

You, the head of Department of Security, recently received a top-secret information that a group of terrorists is planning to transport some WMD ¹ from one city (the source) to another one (the destination). You know their date, source and destination, and they are using the highway network.
　　The highway network consists of bidirectional highways, connecting two distinct city. A vehicle can only enter/exit the highway network at cities only.
　　You may locate some SA (special agents) in some selected cities, so that when the terrorists enter a city under observation (that is, SA is in this city), they would be caught immediately.
　　It is possible to locate SA in all cities, but since controlling a city with SA may cost your department a certain amount of money, which might vary from city to city, and your budget might not be able to bear the full cost of controlling all cities, you must identify a set of cities, that:
　　* all traffic of the terrorists must pass at least one city of the set.
　　* sum of cost of controlling all cities in the set is minimal.
　　You may assume that it is always possible to get from source of the terrorists to their destination.
------------------------------------------------------------
¹ Weapon of Mass Destruction

题意：有一些城市，城市之间有一些边，有通缉犯要从一个城市到另一个城市，为了抓捕通缉犯，你需要调遣兵力守在若干城市，以保证通缉犯无论从哪里走都一定会经过有你的部下看守的城市，问最少需要部署多少个城市。

最小割性质的裸题，就是使原点和汇点不连通的最小割的大小，建边直接跑网络流，最大流＝最小割。

 #include<stdio.h>
 #include<string.h>
 #include<vector>
 #include<queue>
 #include<algorithm>
 using namespace std;
 const int maxm=;
 const int INF=0x7fffffff;

 struct edge{
     int from,to,f;
     edge(int a,int b,int c):from(a),to(b),f(c){}
 };

 struct dinic{
     int s,t,m;
     vector<edge>e;
     vector<int>g[maxm];
     bool vis[maxm];
     int cur[maxm],d[maxm];

     void init(int n){
         for(int i=;i<=n;i++)g[i].clear();
         e.clear();
     }

     void add(int a,int b,int c){
         e.push_back(edge(a,b,c));
         e.push_back(edge(b,a,));
         m=e.size();
         g[a].push_back(m-);
         g[b].push_back(m-);
     }

     bool bfs(){
         memset(vis,,sizeof(vis));
         queue<int>q;
         q.push(s);
         vis[s]=;
         d[s]=;
         while(!q.empty()){
             int u=q.front();
             q.pop();
             for(int i=;i<g[u].size();i++){
                 edge tmp=e[g[u][i]];
                 if(!vis[tmp.to]&&tmp.f>){
                     d[tmp.to]=d[u]+;
                     vis[tmp.to]=;
                     q.push(tmp.to);
                 }
             }
         }
         return vis[t];
     }

     int dfs(int x,int a){
         if(x==t||a==)return a;
         int flow=,f;
         for(int& i=cur[x];i<g[x].size();i++){
             edge& tmp=e[g[x][i]];
             if(d[tmp.to]==d[x]+&&tmp.f>){
                 f=dfs(tmp.to,min(a,tmp.f));
                 tmp.f-=f;
                 e[g[x][i]^].f+=f;
                 flow+=f;
                 a-=f;
                 if(a==)break;
             }
         }
         if(flow==)d[x]=-;
         return flow;
     }

     int mf(int s,int t){
         this->s=s;
         this->t=t;
         int flow=;
         while(bfs()){
             memset(cur,,sizeof(cur));
             flow+=dfs(s,INF);
         }
         return flow;
     }
 };

 int main(){
     int n,m;
     while(scanf("%d%d",&n,&m)!=EOF){
         dinic d;
         d.init(*n+);
         int a,b;
         scanf("%d%d",&a,&b);
         d.add(,a,INF);
         d.add(b+n,*n+,INF);
         int i,j;
         for(i=;i<=n;i++){
             scanf("%d",&a);
             d.add(i,i+n,a);
         }
         for(i=;i<=m;i++){
             scanf("%d%d",&a,&b);
             d.add(a+n,b,INF);
             d.add(b+n,a,INF);
         }
         printf("%d\n",d.mf(,*n+));
     }
     return ;
 }