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 = 20000 + 10;
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 = 0; i < n; i++) G[i].clear();
}

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

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] = 0;

    while(!Q.empty())
    {
        int u = Q.front(); Q.pop();
        for(int i = 0; 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] + 1;
                Q.push(v);
            }
        }
    }

    return vis[t];
}

int DFS(int u, int a)
{
    if(u == t || a == 0) return a;
    int flow = 0, 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] + 1 && (f = DFS(v, min(a, e.cap - e.flow))) > 0)
        {
            flow += f;
            e.flow += f;
            a -= f;
            edges[G[u][i]^1].flow -= f;
            if(a == 0) break;
        }
    }
    return flow;
}

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

int main()
{
    while(scanf("%d%d", &N, &M) == 2)
    {
        n = N + 2;
        init();
        s = 0, t = N + 1;
        for(int i = 1; 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
", Maxflow());
    }

    return 0;
}