bzoj 1834 网络扩容 (费用流)

题目传送门

Description

给定一张有向图，每条边都有一个容量C和一个扩容费用W。这里扩容费用是指将容量扩大1所需的费用。求： 1、 在不扩容的情况下，1到N的最大流； 2、 将1到N的最大流增加K所需的最小扩容费用。

Input

输入文件的第一行包含三个整数N,M,K，表示有向图的点数、边数以及所需要增加的流量。 接下来的M行每行包含四个整数u,v,C,W，表示一条从u到v，容量为C，扩容费用为W的边。

Output

输出文件一行包含两个整数，分别表示问题1和问题2的答案。

Sample Input

5 8 2
1 2 5 8
2 5 9 9
5 1 6 2
5 1 1 8
1 2 8 7
2 5 4 9
1 2 1 1
1 4 2 1

Sample Output

13 19
30%的数据中，N<=100
100%的数据中，N<=1000，M<=5000，K<=10

题解

这道题是一个最大流套一个费用流，题比较裸，跑完最大流后可以在残量网络上直接跑费用流，亦可以再建一个新图。我用的是第二种方法，不过图最开始没建好，总是WA，最后才发现建图有问题。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
using namespace std;

const int INF = 0x7f7f7f7f;
struct edge {
	int to, f, c, w, next;
}Edge[40010];
int head[1010], totE, N, M, K;

void adde(const int &u, const int& v, const int &c, const int &w) {
	edge &ne = Edge[++totE];
	ne.to = v; ne.c = c; ne.f = 0; ne.w = w;
	ne.next = head[u]; head[u] = totE;
}

void adde(const int &u, const int& v, const int &c, const int &w, const int &f) {
	edge &ne = Edge[++totE];
	ne.to = v; ne.c = c; ne.f = f; ne.w = w;
	ne.next = head[u]; head[u] = totE;
}

//

int S, T, d[1010], dt[1010], last[1010];

int dfs(const int &u, int flow) {
	if (u == T) return flow;
	int res = 0, tmp;
	for (int i = last[u]; ~i; i = Edge[i].next) {
		edge &ne = Edge[i];
		if (d[u] > d[ne.to] && ne.c > ne.f) {
			tmp = dfs(ne.to, min(flow, ne.c - ne.f));
			res += tmp; flow -= tmp;
			ne.f += tmp; Edge[i ^ 1].f -= tmp;
			if (!flow) return res;
		}
	}
	if (d[S] >= INF) return res;
	if (!(--dt[d[u]])) d[S] = N;
	++d[u]; ++dt[d[u]]; last[u] = head[u];
	return res;
	
}

int SAP() {
	memset(d, 0, sizeof d);
	memset(dt, 0, sizeof dt);
	S = 1, T = N; dt[0] = N;
	for (int i = 1; i <= N; ++i) last[i] = head[i];
	int ans = 0;
	while (d[S] < N) 
		ans += dfs(S, INF);
	return ans;
}

//

bool inq[1010];
int dis[1010], from[1010], fe[1010];

bool SPFA() {
	memset(dis, 127, sizeof dis);
	queue<int>q;
	from[0] = -1;
	q.push(0); dis[0] = 0;
	int p, fen, v;
	while (!q.empty()) {
		p = q.front(); q.pop();
		inq[p] = 0;
		for (int i = head[p]; ~i; i = Edge[i].next) {
			fen = Edge[i].w; v = Edge[i].to;
			if (dis[p] + fen < dis[v] && Edge[i].c > Edge[i].f) {
				from[v] = p; fe[v] = i;
				dis[v] = dis[p] + fen;
				if (!inq[v]) {
					inq[v] = 1;
					q.push(v);
				}
			}
		}
	}
	return dis[N] < INF;
}


int mcf() {
	int f = INF, p = N;
	while (p) {
		f = min(f, Edge[fe[p]].c - Edge[fe[p]].f);
		p = from[p];
	}
	int ans = 0; p = N;
	while (p) {
		ans += f * Edge[fe[p]].w;
		Edge[fe[p]].f += f;
		Edge[fe[p]^1].f -= f;
		p = from[p];
	}
	return ans;
}

int Expand() {
	memset(inq, 0, sizeof inq);
	memset(head, -1, sizeof head);
	int u, v, fe;
	//puts("");
	for (int i = totE; ~i; i -= 2) {
		u = Edge[i].to; v = Edge[i - 1].to;
		if (Edge[i-1].f < Edge[i-1].c) {
			adde(u, v, Edge[i-1].c, 0, Edge[i-1].f);
			//不能写adde(u, v, Edge[i-1].c - Edge[i-1].f,0)
			//不然流量没法回来
			adde(v, u, 0, 0, Edge[i].f);
		}
		adde(u, v, INF, Edge[i-1].w);
		adde(v, u, 0, -Edge[i - 1].w);
		//printf("%3d -> %3d c = %3d  w = %3d\n",u,v,Edge[i-1].c - Edge[i-1].f,Edge[i-1].w);
	}
	adde(0, 1, K, 0); adde(1, 0, 0, 0);
	int ans = 0;
	while (SPFA()) 
		ans +=mcf();
	return ans;
}

//

int main() {
	scanf("%d%d%d", &N, &M, &K);
	memset(head, -1, sizeof head); totE = -1;
	int u, v, c, w;
	for (int i = 0; i < M; ++i) {
		scanf("%d%d%d%d", &u, &v, &c, &w);
		adde(u, v, c, w); adde(v, u, 0, 0);
	}
	printf("%d ", SAP());
	printf("%d\n", Expand());
	return 0;
}