poj 1459 Power Network【建立超级源点，超级汇点】

Power Network

Time Limit: 2000MS		Memory Limit: 32768K
Total Submissions: 25514		Accepted: 13287

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

There are several data sets in the input. Each data set encodes a power network. It starts with four integers: 0 <= n <= 100 (nodes), 0 <= np <= n (power stations), 0 <= nc <= n (consumers), and 0 <= m <= n^2 (power transport lines). Follow m data triplets (u,v)z, where u and v are node identifiers (starting from 0) and 0 <= z <= 1000 is the value of l_max(u,v). Follow np doublets (u)z, where u is the identifier of a power station and 0 <= z <= 10000 is the value of p_max(u). The data set ends with nc doublets (u)z, where u is the identifier of a consumer and 0 <= z <= 10000 is the value of c_max(u). All input numbers are integers. Except the (u,v)z triplets and the (u)z doublets, which do not contain white spaces, white spaces can occur freely in input. Input data terminate with an end of file and are correct.

Output

For each data set from the input, the program prints on the standard output the maximum amount of power that can be consumed in the corresponding network. Each result has an integral value and is printed from the beginning of a separate line.

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
 
觉得这篇题解写的很不错http://blog.csdn.net/lyy289065406/article/details/6647060

题目意思：给出n个节点（编号0到n-1），这些点里面有发电站（只负责发电），消耗站（只负责消耗电），转运站（只负责转运电）。现在给出每个发电站的最大发电量，消耗站的最大消耗量，转运站的最大转运量， 让你求出消耗站所能消耗的最大电量。 

 

思路：建立超级源0节点        只连通所有发电站，发电站的最大发电量为这条边上的容量。

            建立超级汇n+1节点   只连通所有消耗站，消耗站的最大消耗量为这条边上的容量。 这样讲问题转化成求超级源到超级汇的 最大流问题。

注意：增边的时候，把编号自加一，因为超级源为0节点，而题目中给的节点是从0开始的。

 

#include<stdio.h>
#include<string.h>
#include<stack>
#include<queue>
#include<algorithm>
#define MAX 1100
#define MAXM 40010
#define INF 0x7fffff
using namespace std;
struct node
{
    int from,to,cap,flow,next;
}edge[MAXM];
int n,m,np,nc;
int ans,head[MAX];
int vis[MAX];//用bfs求路径时判断当前点是否进队列，
int dis[MAX];//当前点到源点的距离
int cur[MAX];//保存该节点正在参加计算的弧避免重复计算
void init()
{
    ans=0;
    memset(head,-1,sizeof(head));
}
void add(int u,int v,int w)
{
	node E1={u,v,w,0,head[u]};
	edge[ans]=E1;
	head[u]=ans++;
	node E2={v,u,0,0,head[v]};
	edge[ans]=E2;
	head[v]=ans++;
}
void getmap()
{
	int a, b, d;
	while(m--)
	{
		scanf(" (%d,%d)%d", &a, &b, &d);
		add(a+1, b+1, d);
	}
	while(np--)
	{
		scanf(" (%d)%d", &b, &d);
		add(0, b+1, d);//超级源
	}
	while(nc--)
	{
		scanf(" (%d)%d", &a, &d);
		add(a+1, n+1, d);//超级汇
	}
}
 
int bfs(int beg,int end)
{
    int i;
    memset(vis,0,sizeof(vis));
    memset(dis,-1,sizeof(dis));
    queue<int>q;
    while(!q.empty())
        q.pop();
    vis[beg]=1;
    dis[beg]=0;
    q.push(beg);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(i=head[u];i!=-1;i=edge[i].next)//遍历所有的与u相连的边
        {
            node E=edge[i];
            if(!vis[E.to]&&E.cap>E.flow)//如果边未被访问且流量未满继续操作
            {
                dis[E.to]=dis[u]+1;//建立层次图
                vis[E.to]=1;//将当前点标记
                if(E.to==end)//如果当前点搜索到终点则停止搜索  返回1表示有从原点到达汇点的路径
                    return 1;
                q.push(E.to);//将当前点入队
            }
        }
    }
    return 0;//返回0表示未找到从源点到汇点的路径
}
int dfs(int x,int a,int end)//把找到的这条边上的所有当前流量加上a（a是这条路径中的最小残余流量）
{
    //int i;
    if(x==end||a==0)//如果搜索到终点或者最小的残余流量为0
        return a;
    int flow=0,f;
    for(int& i=cur[x];i!=-1;i=edge[i].next)//i从上次结束时的弧开始
    {
        node& E=edge[i];
        if(dis[E.to]==dis[x]+1&&(f=dfs(E.to,min(a,E.cap-E.flow),end))>0)//如果
        {//bfs中我们已经建立过层次图，现在如果 dis[E.to]==dis[x]+1表示是我们找到的路径
        //如果dfs>0表明最小的残余流量还有，我们要一直找到最小残余流量为0
            E.flow+=f;//正向边当前流量加上最小的残余流量
            edge[i^1].flow-=f;//反向边
            flow+=f;//总流量加上f
            a-=f;//最小可增流量减去f
            if(a==0)
                break;
        }
    }
    return flow;//所有边加上最小残余流量后的值
}
int Maxflow(int beg,int end)
{
    int flow=0;
    while(bfs(beg,end))//存在最短路径
    {
        memcpy(cur,head,sizeof(head));//复制数组
        flow+=dfs(beg,INF,end);
    }
    return flow;//最大流量
}
int main()
{
    int i,j;
    while(scanf("%d%d%d%d",&n,&np,&nc,&m)!=EOF)
    {
        init();
        getmap();
        printf("%d\n",Maxflow(0,n+1));
    }
    return 0;
}