网络吞吐量 [CQOI2015] [网络流]

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

Solution

首先要把最短路的网络建出来，如何建网？

跑一边SPFA，对于一条边u->v，如果dis[u]+e[i].dis==dis[v]，那么这条路就在最短路网中。

建完网后，因为限制流量于点上而不是边上，所以要拆点为边

（如 ——@——   ->　 ——O——a——O——）

连向点a的就连在a左边的点，从a出发的就从a右边的点连出 （可以分别命名为 a,a+n）

从而连接a,a+n的边流量限制为 给定条件，其他边都为INF。

此题请注意值的大小！，务必开long long，inf要开大 （第一遍WA成0分）

Code

 #include<queue>
 #include<cstdio>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 #define ll long long
 #define RG register ll
 #define rep(i,a,b)    for(RG i=a;i<=b;i++)
 #define per(i,a,b)    for(RG i=a;i>=b;i--)
 #define inf (1ll<<60)
 #define maxn 2005
 #define maxm 100005
 using namespace std;
 ll n,m,ct,cnt=,S,T;
 ll hd[maxn],head[maxn],step[maxn],dis[maxn],vis[maxn];
 struct Edge{
     ll u,v,val,next;
 }edge[maxm<<];
 struct E{
     ll v,next,fl;
 }e[maxm<<];
 inline ll read()
 {
     ll x=,f=;char c=getchar();
     while(c<''||c>''){if(c=='-')f=-;c=getchar();}
     while(c>=''&&c<=''){x=x*+c-'';c=getchar();}
     return x*f;
 }

 inline void ad(ll u,ll v,ll val)
 {
     edge[++ct].u=u,edge[ct].v=v,edge[ct].val=val,edge[ct].next=hd[u],hd[u]=ct,swap(u,v);
     edge[++ct].u=u,edge[ct].v=v,edge[ct].val=val,edge[ct].next=hd[u],hd[u]=ct;
 }

 inline void add(ll u,ll v,ll fl)
 {
     e[++cnt].v=v,e[cnt].fl=fl,e[cnt].next=head[u],head[u]=cnt,swap(u,v);
     e[++cnt].v=v,e[cnt].fl= ,e[cnt].next=head[u],head[u]=cnt;
 }

 void SPFA()
 {
     queue<ll> que;
     memset(dis,,sizeof(dis));
     dis[]=,que.push();
     RG u,v;
     while(!que.empty())
     {
         u=que.front(),que.pop();vis[u]=;
         for(RG i=hd[u];i;i=edge[i].next)
         {
             v=edge[i].v;
             if(dis[v]>dis[u]+edge[i].val)
             {
                 dis[v]=dis[u]+edge[i].val;
                 if(!vis[v])    vis[v]=,que.push(v);
             }
         }
     }
 }

 ll bfs()
 {
     queue<ll> que;
     memset(step,-,sizeof(step));step[S]=,que.push(S);
     RG u,v;
     while(!que.empty())
     {
         u=que.front(),que.pop();
         for(RG i=head[u];i;i=e[i].next)
         {
             v=e[i].v;
             if(e[i].fl>&&step[v]==-)
                 step[v]=step[u]+,que.push(v);
         }
     }
     return (step[T]!=-);
 }

 ll dfs(ll u,ll res)
 {
     if(u==T||!res)    return res;
     ll rem=res;
     for(ll i=head[u];i;i=e[i].next)
     {
         ll v=e[i].v;
         if(step[v]==step[u]+&&e[i].fl>)
         {
             ll fl=dfs(v,min(rem,e[i].fl));
             e[i].fl-=fl,e[i^].fl+=fl;
             rem-=fl;
             if(!rem)    break;
         }
     }
     if(rem)    step[u]=-;
     return res-rem;
 }

 void Dinic()
 {
     ll ans=;
     while(bfs())
         ans+=dfs(S,inf);
     printf("%lld",ans);
 }

 int main()
 {
     n=read(),m=read(),S=,T=(n<<);
     RG u,v,val;
     rep(i,,m) u=read(),v=read(),val=read(),ad(u,v,val);
     SPFA();
     rep(i,,ct)
     {
         u=edge[i].u,v=edge[i].v;
         if(dis[u]+edge[i].val==dis[v])
             add(u+n,v,inf);
     }
     read();add(,+n,inf),add(n,n<<,inf);
     rep(i,,n-)
         val=read(),add(i,i+n,val);
     read();
     Dinic();
     return ;
 }

>>点击查看代码<<