洛谷 P3381 【模板】最小费用最大流

题目描述

如题，给出一个网络图，以及其源点和汇点，每条边已知其最大流量和单位流量费用，求出其网络最大流和在最大流情况下的最小费用。

输入输出格式

输入格式：

第一行包含四个正整数N、M、S、T，分别表示点的个数、有向边的个数、源点序号、汇点序号。

接下来M行每行包含四个正整数ui、vi、wi、fi，表示第i条有向边从ui出发，到达vi，边权为wi（即该边最大流量为wi），单位流量的费用为fi。

输出格式：

一行，包含两个整数，依次为最大流量和在最大流量情况下的最小费用。

输入输出样例

输入样例#1：  复制

4 5 4 3
4 2 30 2
4 3 20 3
2 3 20 1
2 1 30 9
1 3 40 5

输出样例#1：  复制

50 280

说明

时空限制：1000ms,128M

（BYX：最后两个点改成了1200ms）

数据规模：

对于30%的数据：N<=10，M<=10

对于70%的数据：N<=1000，M<=1000

对于100%的数据：N<=5000，M<=50000

样例说明：

如图，最优方案如下：

第一条流为4-->3，流量为20，费用为3*20=60。

第二条流为4-->2-->3，流量为20，费用为（2+1）*20=60。

第三条流为4-->2-->1-->3，流量为10，费用为（2+9+5）*10=160。

故最大流量为50，在此状况下最小费用为60+60+160=280。

故输出50 280。

模板

#include
#include
#include
#include
using namespace std;
const int edge_maxn=5e4+7;
const int maxn=5e3+7;
const int inf=0x3f3f3f3f;
struct Node
{
	int to;
	int capa;
	int cost;
	int next;
}edge[edge_maxn<<1];
int cnt;
int head[maxn];
int dis[maxn];
int flow[maxn];
bool vis[maxn];
int pre[maxn];
int rec[maxn];
void init()
{
	cnt=0;
	memset(head,-1,sizeof(head));
	return;
}
void add(int u,int v,int capa,int cost)
{
	edge[cnt].to=v;
	edge[cnt].capa=capa;
	edge[cnt].cost=cost;
	edge[cnt].next=head[u];
	head[u]=cnt++;
	edge[cnt].to=u;
	edge[cnt].capa=0;
	edge[cnt].cost=-cost;
	edge[cnt].next=head[v];
	head[v]=cnt++;
	return;
}
bool spfa(int source,int sink)
{
	memset(dis,inf,sizeof(dis));
	memset(vis,false,sizeof(vis));
	memset(flow,inf,sizeof(flow));
	memset(pre,-1,sizeof(pre));
	memset(rec,-1,sizeof(rec));
	queue que;
	que.push(source);
	vis[source]=true;
	dis[source]=0;
	while(!que.empty())
	{
		int node=que.front();
		que.pop();
		vis[node]=false;
		for(int i=head[node];~i;i=edge[i].next)
		{
			int v=edge[i].to;
			if(edge[i].capa&&dis[v]>dis[node]+edge[i].cost)
			{
				dis[v]=dis[node]+edge[i].cost;
				rec[v]=i;
				pre[v]=node;
				if(!vis[v])
				{
					que.push(v);
					vis[v]=true;
				}
			}
		}
	}
	return dis[sink]!=inf;
}
void mcmf(int source,int sink)
{
	int mincost=0;
	int maxflow=0;
	while(spfa(source,sink))
	{
		int flow=inf;
		int node=sink;
		while(node!=source)
		{
			flow=min(flow,edge[rec[node]].capa);
			node=pre[node];
		}
		maxflow+=flow;
		node=sink;
		while(node!=source)
		{
			mincost+=flow*edge[rec[node]].cost;
			edge[rec[node]].capa-=flow;
			edge[rec[node]^1].capa+=flow;
			node=pre[node];
		}
	}
	printf("%d %d\n",maxflow,mincost);
	//cout<