20-1-30-最大流SAP-POJ1459

POJ1459(最大流)

Power Network

Time Limit: 2000MS		Memory Limit: 32768K
Total Submissions: 32373		Accepted: 16573

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) <= pmax(u) of power, may consume an amount 0 <= c(u) <= min(s(u),cmax(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) <= lmax(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.
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RsXCIb9P-1580480668567)(D:\AFiles\TyporaPictures\1459_1-1580480218560.jpg)]
An example is in figure 1. The label x/y of power station u shows that p(u)=x and pmax(u)=y. The label x/y of consumer u shows that c(u)=x and cmax(u)=y. The label x/y of power transport line (u,v) shows that l(u,v)=x and lmax(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 lmax(u,v). Follow np doublets (u)z, where u is the identifier of a power station and 0 <= z <= 10000 is the value of pmax(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 cmax(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

Hint

The sample input contains two data sets. The first data set encodes a network with 2 nodes, power station 0 with pmax(0)=15 and consumer 1 with cmax(1)=20, and 2 power transport lines with lmax(0,1)=20 and lmax(1,0)=10. The maximum value of Con is 15. The second data set encodes the network from figure 1.

Source

Southeastern Europe 2003

• 采用kuangbin的最大流板子
• 最大流SAP算法裸题, 需要注意的是, 由于是多个源点和多个汇点的问题, 需要抽象出一个能发出无穷大流的源点, 记为start, 和一个可以接受无穷大流的汇点, 记为end, 图初始化时, start点到所有power(源点)的距离初始化为power的Capacity, end到所有汇点的那条边初始化为汇点的Capacity.
• 关于最大流的sap参考
• 算法设计与分析, 王晓东

#include<iostream>
#include<algorithm>
#include<queue>
//EK算法,Dinic算法,SAP算法
//SAP算法的邻接表形式
#include<cstring>
using namespace std;
const int MAXN = 100010;//点数的最大值
const int MAXM = 400010;//边数的最大值
const int INF = 0x3f3f3f3f;

//临接表的方式建立图
struct Edge {
	int to, v, /*载荷*/cap, /*流量*/flow;
}edge[MAXM];//注意是MAXM
int tol;//边的总数
int head[MAXN];

int gap[MAXN];//距离标号为i的点有多少个
int dep[MAXN];
int pre[MAXN];//记录路径, 一个顶点的前一个顶点的编号, 第一个设置为-1
int cur[MAXN];//head的临时顶点 

//边的初始化
void init() {
	tol = 0;
	memset(head, -1, sizeof(head));
}

//加边，单向图三个参数，双向图四个参数
void addedge(int u, int v, int w/*承载能力*/, int rw = 0/*反向边的承载能力*/) {
	edge[tol].to = v; edge[tol].cap = w; edge[tol].v = head[u];
	edge[tol].flow = 0/*当前流量设置为0*/; head[u] = tol++;
	edge[tol].to = u; edge[tol].cap = rw; edge[tol].v = head[v];
	edge[tol].flow = 0; head[v] = tol++;
}

//SAP算法:求最大流有一种经典的算法，就是每次找增广路时用BFS找，
	//保证找到的增广路是弧数最少的，也就是所谓的Edmonds-Karp算法。
	//O(V*E^2)
//输入参数：起点、终点、点的总数
	//点的编号没有影响，只要输入点的总数
int sap(int start/*起点的编号*/, int end/*终点的编号*/, int N/*顶点的总数*/) {
	memset(gap, 0, sizeof(gap));
	memset(dep, 0, sizeof(dep));

	memcpy(cur, head, sizeof(head));

	int u = start;
	pre[u] = -1;
	gap[0] = N;//距离标号为0的点有n个
	int ans = 0;
	//dep[start]初始化为0
	while (dep[start] < N) {
		//找到增光路
		if (u == end) {
			//寻找路径上残量网络中最小的流量
			int Min = INF;
			for (int i = pre[u]; i != -1; i = pre[edge[i ^ 1].to]/**/)
				if (Min > edge[i].cap - edge[i].flow)
					Min = edge[i].cap - edge[i].flow;
			for (int i = pre[u]; i != -1; i = pre[edge[i ^ 1].to]) {
				edge[i].flow += Min;
				edge[i ^ 1].flow -= Min;

			}
			u = start;
			ans += Min;
			continue;
		}
		//u<end
		bool flag = false;
		int v;

		//遍历顶点u的所有的边v
		for (int i = cur[u]; i != -1; i = edge[i].v) {
			v = edge[i].to;//
			if (edge[i].cap - edge[i].flow && dep[v] + 1 == dep[u]/*寻找允许路*/)
			{
				flag = true;
				cur[u] = pre[v] = i;
				break;
			}
		}
		//找到了允许路
		if (flag) {
			u = v;
			continue;
		}
		int Min = N;
		for (int i = head[u]; i != -1; i = edge[i].v)
			if (edge[i].cap - edge[i].flow && dep[edge[i].to] < Min)
			{
				Min = dep[edge[i].to];
				cur[u] = i;
			}
		gap[dep[u]]--;
		if (!gap[dep[u]])return ans;
		dep[u] = Min + 1;
		gap[dep[u]]++;
		if (u != start) u = edge[pre[u] ^ 1].to;
	}
	return ans;
}
int n, np, nc, m;
int main(){
    char parenthesis;
    int u, v;
    int value;
    while (cin >> n >> np >> nc >> m){
        init();
        int start = n;
        int end = n + 1;
        for (int i = 0; i < m; i++){
            cin >> parenthesis;
            cin >> u;//开始点
            cin >> parenthesis;
            cin >> v;//结束点
            cin >> parenthesis;
            cin >> value;
			if (u == v) {
				continue;
			}
			addedge(u, v, value);
        }
        for (int i = 0; i < np; i++){
            cin >> parenthesis;
            cin >> u;//顶点的序号
            cin >> parenthesis;
            cin >> value;
			addedge(n, u, value);
        }
        for (int i = 0; i < nc; i++){
            cin >> parenthesis;
            cin >> u;
            cin >> parenthesis;
            cin >> value;
			addedge(u, end, value);
        }
        cout << sap(start, end, n + 2) << endl;
    }
    return 0;
}

   cin >> u;
        cin >> parenthesis;
        cin >> value;
		addedge(u, end, value);
    }
    cout << sap(start, end, n + 2) << endl;
}
return 0;

}