POJ 3469 网络流最小割

将两个CPU分别视作源点和汇点

对于那些不在同一个CPU中的模块会产生的代价作为一条双向的容量弧

这里每个模块可以在任意一个CPU中运行，相当于寻找一个割，分割后，在S集合中的模块安装在第一个CPU中

那么在T集合中的模块就是在第二个CPU中，所求的最小割也正是最小耗费

根据最大流=最小割的原理，这里相当于是在求最大流

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <queue>

 using namespace std;
 const int N = ;
 const int INF = 0x3f3f3f3f;
 int lev[N],first[N],k;

 struct Edge{
     int u , v , cap , flow , next;
 }e[N*];

 void add_edge(int u , int v , int cap)
 {
     e[k].u=u , e[k].v = v , e[k].cap=cap , e[k].flow= , e[k].next = first[u];
     first[u]=k++;
 }
 //寻找层次网络是否存在
 bool find_level(int n)
 {
     queue<int> q;
     q.push();
     memset(lev ,  , sizeof(lev));
     lev[]=;
     while(!q.empty())
     {
         int u=q.front();
         q.pop();
         for(int i=first[u] ; i!=- ; i=e[i].next){
             int v = e[i].v;
             if(!lev[v] && e[i].cap > e[i].flow){
                 lev[v] = lev[u]+;
                 q.push(v);
             }
         }
     }
     return lev[n+]>;
 }

 int Dinic(int n , int u , int sum)
 {
     int s = sum , t;
     if(u == n+) return sum;
     for(int i=first[u] ; i!=- ;i=e[i].next)
     {
         int v = e[i].v;
         if(lev[v] != lev[u]+ || e[i].cap <= e[i].flow) continue;
         t = Dinic(n , v , min(sum , e[i].cap - e[i].flow));
         e[i].flow += t;
         e[i^].flow -= t;
         sum-=t;
     }
     return s-sum;
 }

 int main()
 {
    // freopen("a.in" , "r" , stdin);
     int n , m , u , v , cap1 , cap2;
     while(scanf("%d%d" , &n , &m) == )
     {
         k=;
         memset(first , - , sizeof(first));
         for(int i= ; i<n ; i++)
         {
             scanf("%d%d" , &cap1 , &cap2);
             //添加双向弧
             add_edge( , i+ , cap1);
             add_edge(i+ ,  , );

             add_edge(i+ , n+ , cap2);
             add_edge(n+ , i+ , );
         }
         for(int i= ; i<m ; i++)
         {
             scanf("%d%d%d" , &u , &v , &cap1);
             add_edge(u , v , cap1);
             add_edge(v , u , cap1);
         }
         int max_flow = ;
         while(find_level(n)){
             max_flow += Dinic(n ,  , INF);
         }
         printf("%d\n" , max_flow);
     }
     return ;
 }