BZOJ1834 [ZJOI2010]network 网络扩容【最大流，费用流】

1834: [ZJOI2010]network 网络扩容

Time Limit: 3 Sec Memory Limit: 64 MB

Submit: 3394 Solved: 1774

[Submit][Status][Discuss]

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

首先T1打板就好了

本题难点在T2，如何最小费用扩展网络？

其实就是最小费用流嘛

我们对所有的原边再加一条流量无限的费用为w的边，再加一个超级源指向源点，容量K费用0

再跑一遍费用流就好了

#include<iostream>

#include<cstdio>

#include<queue>

#include<cstring>

#include<algorithm>

#define LL long long int

#define REP(i,n) for (int i = 1; i <= (n); i++)

#define Redge(u) for (int k = head[u]; k != -1; k = edge[k].next)

using namespace std;

const int maxn = 1005,maxm = 30005,INF = 1000000000;

inline int RD(){

	int out = 0,flag = 1; char c = getchar();

	while (c < 48 || c > 57) {if (c == '-') flag = -1; c = getchar();}

	while (c >= 48 && c <= 57) {out = (out << 1) + (out << 3) + c - '0'; c = getchar();}

	return out * flag;

}

int N,M,K,head[maxn],nedge = 0,d[maxn],cur[maxn],S,T,p[maxn],f[maxn];

bool vis[maxn];

struct EDGE{int from,to,f,w,next;}edge[maxm];

inline void build(int u,int v,int f,int w){

	edge[nedge] = (EDGE){u,v,f,w,head[u]}; head[u] = nedge++;

	edge[nedge] = (EDGE){v,u,0,-w,head[v]}; head[v] = nedge++;

}

bool bfs(){

	queue<int> q;

	REP(i,N) vis[i] = false,d[i] = INF;

	vis[S] = true; d[S] = 0; q.push(S);

	int u,to;

	while (!q.empty()){

		u = q.front();

		q.pop();

		Redge(u) if (edge[k].f && !vis[to = edge[k].to]){

			d[to] = d[u] + 1;

			vis[to] = true;

			q.push(to);

		}

	}

	return vis[T];

}

int dfs(int u,int minf){

	if (u == T || !minf) return minf;

	int flow = 0,f,to;

	if (cur[u] == -2) cur[u] = head[u];

	for (int& k = cur[u]; k != -1; k = edge[k].next)

		if (d[to = edge[k].to] == d[u] + 1 && (f = dfs(to,min(minf,edge[k].f)))){

			edge[k].f -= f;

			edge[k ^ 1].f += f;

			flow += f;

			minf -= f;

			if (!minf) break;

		}

	return flow;

}

int maxflow(){

	int flow = 0;

	while (bfs()){fill(cur,cur + maxn,-2); flow += dfs(S,INF);}

	return flow;

}

int mincost(){

	int cost = 0,flow = 0;

	while (true){

		queue<int> q;

		for (int i = 0; i <= N; i++) d[i] = INF,vis[i] = false;

		d[S] = 0; f[S] = INF; p[S] = 0;

		q.push(S);

		int to,u;

		while (!q.empty()){

			u = q.front(); q.pop();

			vis[u] = false;

			Redge(u) if (edge[k].f && d[to = edge[k].to] > d[u] + edge[k].w){

				d[to] = d[u] + edge[k].w; p[to] = k; f[to] = min(f[u],edge[k].f);

				if (!vis[to]) q.push(to),vis[to] = true;

			}

		}

		if (d[T] == INF) break;

		flow += f[T];

		cost += f[T] * d[T];

		u = T;

		while (u != S){

			edge[p[u]].f -= f[T];

			edge[p[u] ^ 1].f += f[T];

			u = edge[p[u]].from;

		}

	}

	return cost;

}

int main(){

	memset(head,-1,sizeof(head));

	N = RD(); M = RD(); K = RD(); S = 1; T = N;

	int a,b,f,w;

	while (M--){

		a = RD(); b = RD(); f = RD(); w = RD();

		build(a,b,f,w);

	}

	int ans1 = maxflow(),ans2,E = nedge;

	for (int i = 0; i < E; i += 2){

		build(edge[i].from,edge[i].to,INF,edge[i].w);

		edge[i].w = edge[i ^ 1].w = 0;

	}

	S = 0; build(S,1,K,0);

	ans2 = mincost();

	cout<<ans1<<' '<<ans2<<endl;

	return 0;

}