POJ 3469 Dual Core CPU【最小割】

题意： 计算机里配置了双核的CPU， 有 N 个原件， 知道了在每个原件在 每个CPU 上的 耗费，其中有 M 对原件需要协同工作，并且有协同工作的耗费，如果这些对原件是在同一个CPU上工作的话，就不计算协同工作的耗费。

分析：

        建图：

         把两个CPU 分别看成是 源点和汇点。

         从源点 到 每个顶点连接一条  容量为 AI 的边，

         从每个顶点 到 汇点 连接一条容量为 BI 的边，

         如果 两个原件具有协同工作关系，就在两个原件之间连接一条 容量为 w 的双向边。

         求出的最小割即为最小费用，  而最小割可以通过求最大流来求得。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define clr(x)memset(x,0,sizeof(x))
#define min(a,b)(a)<(b)?(a):(b)
const int INF=0x1f1f1f1f;
const int maxn=20005;
const int maxm=800005;
struct node
{
    int c,next,to;
}e[maxm];
int tot;
int head[maxn];
void add(int s,int u,int flow)
{
    e[tot].to=u;
    e[tot].c=flow;
    e[tot].next=head[s];
    head[s]=tot++;
}
int max_flow(int st,int end,int n)
{    
    int numh[maxn],h[maxn],curedge[maxn],pre[maxn];
    int cur_flow,maxflow=0,u,tmp,neck,i;
    clr(h);   clr(numh);
    memset(pre,0xff,sizeof(pre));
    for(i=1;i<=n;i++)
        curedge[i]=head[i];
    numh[0]=n;
    u=st;
    while(h[st]<n)
    {
        if(u==end)
        {
            cur_flow=INF;
            for(i=st;i!=end;i=e[curedge[i]].to)
                if(cur_flow>e[curedge[i]].c)
                {
                    neck=i;
                    cur_flow=e[curedge[i]].c;
                }
            for(i=st;i!=end;i=e[curedge[i]].to)
            {
                tmp=curedge[i];
                e[tmp].c-=cur_flow;
                e[tmp^1].c+=cur_flow;
            }
            maxflow+=cur_flow;
            u=neck;
        }
        for(i=curedge[u];i!=-1;i=e[i].next)
            if(e[i].c&&h[u]==h[e[i].to]+1)
                break;
        if(i!=-1)
        {
            curedge[u]=i;
            pre[e[i].to]=u;
            u=e[i].to;
        }
        else 
        {
            if(--numh[h[u]]==0) break;
            curedge[u]=head[u];
            for(tmp=n,i=head[u];i!=-1;i=e[i].next)
                if(e[i].c)
                    tmp=min(tmp,h[e[i].to]);
            h[u]=tmp+1;
            ++numh[h[u]];
            if(u!=st)
                u=pre[u];
        }
    }
    return maxflow;
}
int main()
{
    int flow,a,b,w,i,n,m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        tot=0;
        memset(head,0xff,sizeof(head));
        for(i=2;i<=n+1;i++)
        {
            scanf("%d%d",&a,&b);
            add(1,i,a);
            add(i,1,0);
            add(i,n+2,b);
            add(n+2,i,0);
        }
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&w);
            add(a+1,b+1,w);
            add(b+1,a+1,w);
        }
        flow=max_flow(1,n+2,n+2);
        printf("%d\n",flow);
    }
    return 0;
}