POJ 3469 最小割 Dual Core CPU

题意：

一个双核CPU上运行N个模块，每个模块在两个核上运行的费用分别为A_i和B_i。

同时，有M对模块需要进行数据交换，如果这两个模块不在同一个核上运行需要额外花费。

求运行N个模块的最小费用。

分析：

这是一个集合划分问题，将这两个模块划分成两个集合，一个集合中的模块在核A上运行，一个在核B上运行。

增加一个源点S和汇点T，每个模块分别和源点和汇点连一条边，容量为在该核上运行的花费。

然后在两个模块对之间连容量为额外花费的双向边。

图中的一个割就对应一个集合的划分，最小割就是最小的总费用。

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

 const int maxn =  + ;
 const int INF = 0x3f3f3f3f;

 int n, s, t;
 int N, M;

 struct Edge
 {
     int from, to, cap, flow;
     Edge(int u, int v, int c, int f):from(u), to(v), cap(c), flow(f) {}
 };

 vector<Edge> edges;
 vector<int> G[maxn];

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

 void AddEdge(int u, int v, int c)
 {
     edges.push_back(Edge(u, v, c, ));
     edges.push_back(Edge(v, u, , ));
     int m = edges.size();
     G[u].push_back(m - );
     G[v].push_back(m - );
 }

 bool vis[maxn];
 int d[maxn], cur[maxn];

 bool BFS()
 {
     memset(vis, false, sizeof(vis));
     vis[s] = true;
     queue<int> Q;
     Q.push(s);
     d[s] = ;

     while(!Q.empty())
     {
         int u = Q.front(); Q.pop();
         for(int i = ; i < G[u].size(); i++)
         {
             Edge& e = edges[G[u][i]];
             int v = e.to;
             if(!vis[v] && e.cap > e.flow)
             {
                 vis[v] = true;
                 d[v] = d[u] + ;
                 Q.push(v);
             }
         }
     }

     return vis[t];
 }

 int DFS(int u, int a)
 {
     if(u == t || a == ) return a;
     int flow = , f;
     for(int& i = cur[u]; i < G[u].size(); i++)
     {
         Edge& e = edges[G[u][i]];
         int v = e.to;
         if(d[v] == d[u] +  && (f = DFS(v, min(a, e.cap - e.flow))) > )
         {
             flow += f;
             e.flow += f;
             a -= f;
             edges[G[u][i]^].flow -= f;
             if(a == ) break;
         }
     }
     return flow;
 }

 int Maxflow()
 {
     int flow = ;
     while(BFS())
     {
         memset(cur, , sizeof(cur));
         flow += DFS(s, INF);
     }
     return flow;
 }

 int main()
 {
     while(scanf("%d%d", &N, &M) == )
     {
         n = N + ;
         init();
         s = , t = N + ;
         for(int i = ; i <= N; i++)
         {
             int a, b; scanf("%d%d", &a, &b);
             AddEdge(s, i, a);
             AddEdge(i, t, b);
         }
         while(M--)
         {
             int a, b, w; scanf("%d%d%d", &a, &b, &w);
             AddEdge(a, b, w);
             AddEdge(b, a, w);
         }

         printf("%d\n", Maxflow());
     }

     return ;
 }

代码君