bzoj 3931: [CQOI2015]网络吞吐量（最短路+网络流）

3931: [CQOI2015]网络吞吐量

Time Limit: 10 Sec   Memory Limit: 512 MB
Submit: 1194   Solved: 508
[ Submit][ Status][ Discuss]

Description

 路由是指通过计算机网络把信息从源地址传输到目的地址的活动，也是计算机网络设计中的重点和难点。网络中实现路由转发的硬件设备称为路由器。为了使数据包最快的到达目的地，路由器需要选择最优的路径转发数据包。例如在常用的路由算法OSPF(开放式最短路径优先)中，路由器会使用经典的Dijkstra算法计算最短路径，然后尽量沿最短路径转发数据包。现在，若已知一个计算机网络中各路由器间的连接情况，以及各个路由器的最大吞吐量（即每秒能转发的数据包数量），假设所有数据包一定沿最短路径转发，试计算从路由器1到路由器n的网络的最大吞吐量。计算中忽略转发及传输的时间开销，不考虑链路的带宽限制，即认为数据包可以瞬间通过网络。路由器1到路由器n作为起点和终点，自身的吞吐量不用考虑，网络上也不存在将1和n直接相连的链路。

Input

输入文件第一行包含两个空格分开的正整数n和m，分别表示路由器数量和链路的数量。网络中的路由器使用1到n编号。接下来m行，每行包含三个空格分开的正整数a、b和d，表示从路由器a到路由器b存在一条距离为d的双向链路。 接下来n行，每行包含一个正整数c，分别给出每一个路由器的吞吐量。

Output

输出一个整数，为题目所求吞吐量。

Sample Input

7 10
1 2 2
1 5 2
2 4 1
2 3 3
3 7 1
4 5 4
4 3 1
4 6 1
5 6 2
6 7 1
1
100
20
50
20
60
1

Sample Output

70

HINT

 对于100%的数据，n≤500，m≤100000，d,c≤10^9

Source

[ Submit][ Status][ Discuss] 题解：跑一遍最短路，然后把最短路上的边加入网络流的图中，跑网络流就可以了。

注意需要拆点来限流。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cmath>
#define N 12000
#define M 400003
#define LL long long
using namespace std;
int m,n;
int next[M],point[N],v[M],tot;
int next1[M],point1[N],v1[M],tot1,w[M];
LL dis[M],dis1[M],len[M],remain[M],c[M];
int deep[N],num[N],cur[N],last[N],can[N];
int a[M],b[M];
const LL inf=1e14;
void insert(int x,int y,LL z)
{
	tot1++; w[tot1]=x; next1[tot1]=point1[x]; point1[x]=tot1; v1[tot1]=y; len[tot1]=z;
	tot1++; w[tot1]=y; next1[tot1]=point1[y]; point1[y]=tot1; v1[tot1]=x; len[tot1]=z;
}
void add(int x,int y,LL z)
{
	tot++; next[tot]=point[x]; point[x]=tot; v[tot]=y; remain[tot]=z;
	tot++; next[tot]=point[y]; point[y]=tot; v[tot]=x; remain[tot]=0;
}
LL addflow(int s,int t)
{
	int now=t; LL ans=inf;
	while (now!=s)
	{
		ans=min(ans,remain[last[now]]);
		now=v[last[now]^1];
	}
	now=t;
	while (now!=s)
	{
		remain[last[now]]-=ans;
		remain[last[now]^1]+=ans;
		now=v[last[now]^1];
	}
	return ans;
}
void bfs(int s,int t)
{
	for (int i=s;i<=t;i++)
	 deep[i]=t;
	deep[t]=0; 
    queue<int> p; p.push(t);
    while (!p.empty())
    {
    	int now=p.front(); p.pop();
    	for (int i=point[now];i!=-1;i=next[i])
    	 if (deep[v[i]]==t&&remain[i^1])
    	  deep[v[i]]=deep[now]+1,p.push(v[i]);
    }
}
LL isap(int s,int t)
{
	bfs(s,t);
	for (int i=s;i<=t;i++) cur[i]=point[i];
	for (int i=s;i<=t;i++) num[deep[i]]++;
	int now=s; LL ans=0;
	while (deep[s]<t)
	{
		if (now==t)
		 {
		 	ans+=(LL)addflow(s,t);
		 	now=s;
		 }
		bool f=false;
		for (int i=cur[now];i!=-1;i=next[i])
		 if (deep[v[i]]+1==deep[now]&&remain[i])
		  {
		  	f=true;
		  	cur[now]=i;
		  	last[v[i]]=i;
		  	now=v[i];
		  	break;
		  }
		if (!f)
		{
			int minn=t;
			for (int i=point[now];i!=-1;i=next[i])
			 if (remain[i]) minn=min(deep[v[i]],minn);
			if (!--num[deep[now]]) break;
			deep[now]=minn+1;
			num[deep[now]]++; 
			cur[now]=point[now];
			if (now!=s) now=v[last[now]^1];
		}
	}
	return ans;
}
void spfa(LL f[],int s)
{
	memset(can,0,sizeof(can));
	f[s]=0; can[s]=1;
	queue<int> p;p.push(s);
	while (!p.empty())
	{
		int now=p.front(); p.pop();
		for (int i=point1[now];i;i=next1[i])
		 if (f[v1[i]]>f[now]+len[i])
		  {
		  	f[v1[i]]=f[now]+len[i];
		  	if (can[v1[i]]==0)
		  	{
		  		can[v1[i]]=1; 
		  		p.push(v1[i]);
		  	}
		  }
		can[now]=0;
	}
}
int main()
{
	scanf("%d%d",&n,&m); 
	for (int i=1;i<=m;i++)
	 {
	 	int x,y;LL z; scanf("%d%d%lld",&x,&y,&z);
	 	a[i]=x; b[i]=y; c[i]=z;
	 	insert(x,y,z);
	 }
	memset(dis,127,sizeof(dis));
	memset(dis1,127,sizeof(dis1));
	spfa(dis,1);
	spfa(dis1,n);  LL lmin=dis[n];
	memset(next,-1,sizeof(next));
	memset(point,-1,sizeof(point));
	tot=-1; 
    for (int i=1;i<=m;i++)
    {
      if (dis[a[i]]+c[i]==dis[b[i]])
       add(a[i]+n,b[i],inf);
      if (dis[b[i]]+c[i]==dis[a[i]])
       add(b[i]+n,a[i],inf);
     }
	for (int i=1;i<=n;i++)
	 {
	 	LL x; scanf("%lld",&x); 
	 	if (i==1||i==n) add(i,i+n,inf);
	 	else add(i,i+n,x);
	 }
	printf("%lld\n",isap(1,n*2));
	return 0;
}