网络吞吐量 [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

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 ;

 }

>>点击查看代码<<