poj 3469 Dual Core CPU

题意：有n个任务，已知每个任务在CPU的核1上运行需要多久，在核2上运行需要多久，并且还存在一些约束，假设其中有若干对任务，其中一个在核1上运行，一个在核2上运行，那么他们还要额外多运行一些时间，假设他们都在一个核上运行，则不需要这些额外的时间，问要完成这n个任务最少需要多少时间。

看到两核，也就是把任务分成两部分，就想到了最小割，核1作为超级远点，核2作为超级汇点，超级源点和每个任务相连，权值为这个任务在核1上运行的时间，超级汇点和每个任务相连，权值为该任务在核2上运行的时间，存在约束的任务间，互相间连一条边，权值为额外需要的时间，跑一遍sap（）即可。

#include<stdio.h>
#include<string.h>
#include<iostream>
#define N 200000
#define inf 1000000000
using namespace std;
struct Edge{
int u,v,c,next;
}edge[1000010];
int head[80010],pre[80010],cur[1000010],dis[80010],gap[1000010];
int start,end,n,m,e,a,b,c;

void add_adge(int u,int v,int c1)
{
edge[e].u=u; edge[e].v=v; edge[e].c=c1; edge[e].next=head[u]; head[u]=e++;
edge[e].u=v; edge[e].v=u; edge[e].c=0;  edge[e].next=head[v]; head[v]=e++;
}

int sap()
{
int flow=0,aug=inf,u;
bool flag;
for(int i=0; i<=n+1; i++)
{
cur[i]=head[i];
gap[i]=dis[i]=0;
}
gap[start]=n+2;
u=pre[start]=start;
while(dis[start]<n+2)
{
flag=0;
for(int &j=cur[u]; j!=-1; j=edge[j].next)
{
int v=edge[j].v;
if(edge[j].c>0&&dis[u]==dis[v]+1)
{
flag=1;
if(edge[j].c<aug) aug=edge[j].c;
pre[v]=u;
u=v;
if(u==n+1)
{
flow+=aug;
while(u!=0)
{
u=pre[u];
edge[cur[u]].c-=aug;
edge[cur[u]^1].c+=aug;
}
aug=inf;
}
break;
}
}
if(flag) continue;
int mindis=n+2;
for(int j=head[u]; j!=-1; j=edge[j].next)
{
int v=edge[j].v;
if(edge[j].c>0&&dis[v]<mindis)
{
mindis=dis[v];
cur[u]=j;
}
}
if((--gap[dis[u]])==0)
break;
gap[dis[u]=mindis+1]++;
u=pre[u];
}
return flow;
}

int main()
{
while(scanf("%d%d",&n,&m)!=EOF)
{
e=0,start=0;end=n+1;
memset(head,-1,sizeof(head));
for(int i=1;i<=n;i++)
{
scanf("%d%d",&a,&b);
add_adge(0,i,a);
add_adge(i,n+1,b);
}
for(int i=1;i<=m;i++)
{
scanf("%d%d%d",&a,&b,&c);
add_adge(a,b,c);
add_adge(b,a,c);
}
printf("%d\n",sap());
}
return 0;
}