Description

A power network consists of nodes (power stations, consumers and dispatchers) connected by power transport lines. A node u may be supplied with an amount s(u) >= 0 of power, may produce an amount 0 <= p(u) <= p_max(u) of power, may consume an amount 0 <= c(u) <= min(s(u),c_max(u)) of power, and may deliver an amount d(u)=s(u)+p(u)-c(u) of power. The following restrictions apply: c(u)=0 for any power station, p(u)=0 for any consumer, and p(u)=c(u)=0 for any dispatcher. There is at most one power transport line (u,v) from a node u to a node v in the net; it transports an amount 0 <= l(u,v) <= l_max(u,v) of power delivered by u to v. Let Con=Σ_uc(u) be the power consumed in the net. The problem is to compute the maximum value of Con. 

An example is in figure 1. The label x/y of power station u shows that p(u)=x and p_max(u)=y. The label x/y of consumer u shows that c(u)=x and c_max(u)=y. The label x/y of power transport line (u,v) shows that l(u,v)=x and l_max(u,v)=y. The power consumed is Con=6. Notice that there are other possible states of the network but the value of Con cannot exceed 6. 

Input

Output

Sample Input

2 1 1 2 (0,1)20 (1,0)10 (0)15 (1)20
7 2 3 13 (0,0)1 (0,1)2 (0,2)5 (1,0)1 (1,2)8 (2,3)1 (2,4)7
         (3,5)2 (3,6)5 (4,2)7 (4,3)5 (4,5)1 (6,0)5
         (0)5 (1)2 (3)2 (4)1 (5)4

Sample Output

15
6

Hint

题意：有n个结点，np个发电站，nc个消费者，m个电力运输线。接下去是n条边的信息(u,v)cost，cost表示边(u,v)的最大流量；a个发电站的信息(u)cost，cost表示发电站u能提供的最大流量；b个用户的信息(v)cost，cost表示每个用户v能接受的最大流量。
思路：在图中添加1个源点S和汇点T，将S和每个发电站相连，边的权值是发电站能提供的最大流量；将每个用户和T相连，边的权值是每个用户能接受的最大流量。从而转化成了一般的最大网络流问题，然后求解。（自己语言总结不好，觉得这个能看懂，就贴一下）

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
using namespace std;
const int inf=0x3f3f3f3f;
int head[10010],num[10010],d[10010],cur[10010],q[10010],pre[10010];
int n,m,s,t,cnt,nv;
int maxint=inf;
struct node {
        int v,cap;
        int next;
} edge[100010];
void add(int u,int v,int cap)
{
        edge[cnt].v=v;
        edge[cnt].cap=cap;
        edge[cnt].next=head[u];
        head[u]=cnt++;
        edge[cnt].v=u;
        edge[cnt].cap=0;
        edge[cnt].next=head[v];
        head[v]=cnt++;
}
void bfs()
{
        int i,j;
        memset(num,0,sizeof(num));
        memset(d,-1,sizeof(d));
        int f1=0,f2=0;
        q[f1++]=t;
        d[t]=0;
        num[0]=1;
        while(f1>=f2) {
                int u=q[f2++];
                for(i=head[u]; i!=-1; i=edge[i].next) {
                        int v=edge[i].v;
                        if(d[v]!=-1) continue;
                        d[v]=d[u]+1;
                        num[d[v]]++;
                        q[f1++]=v;
                }
        }
}
void isap()
{
        memcpy(cur,head,sizeof(cur));
        bfs();
        int flow=0,u=pre[s]=s,i;
        while(d[s]<nv) {
                if(u==t) {
                        int f=maxint,pos;
                        for(i=s; i!=t; i=edge[cur[i]].v) {
                                if(f>edge[cur[i]].cap) {
                                        f=edge[cur[i]].cap;
                                        pos=i;
                                }
                        }
                        for(i=s; i!=t; i=edge[cur[i]].v) {
                                edge[cur[i]].cap-=f;
                                edge[cur[i]^1].cap+=f;
                        }
                        flow+=f;
                        u=pos;
                }
                for(i=cur[u]; i!=-1; i=edge[i].next) {
                        if(d[edge[i].v]+1==d[u]&&edge[i].cap)
                                break;
                }
                if(i!=-1) {
                        cur[u]=i;
                        pre[edge[i].v]=u;
                        u=edge[i].v;
                } else {
                        if(--num[d[u]]==0) break;
                        int mind=nv;
                        for(i=head[u]; i!=-1; i=edge[i].next) {
                                if(mind>d[edge[i].v]&&edge[i].cap) {
                                        mind=d[edge[i].v];
                                        cur[u]=i;
                                }
                        }
                        d[u]=mind+1;
                        num[d[u]]++;
                        u=pre[u];
                }

        }
        printf("%d\n",flow);
}
int main()
{
        int np, nc,a, b, c;
        char ch;
        while(scanf("%d%d%d%d",&n,&np,&nc,&m)!=EOF) {
                memset(head,-1,sizeof(head));
                cnt=0;
                s=0;
                t=n+1;
                nv=n+2;
                while(m--) {
                        while(getchar()!='(');
                        scanf("%d,%d)%d",&a,&b,&c);
                        add(a+1,b+1,c);
                }
                while(np--) {
                        while(getchar()!='(');
                        scanf("%d)%d",&a,&c);
                        add(0,a+1,c);
                }
                while(nc--) {
                        while(getchar()!='(');
                        scanf("%d)%d",&a,&c);
                        add(a+1,t,c);
                }
                isap();
        }
        return 0;
}

POJ 1459-Power Network(网络流_最大流 ISAP算法)