网络吞吐量 [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=1,S,T;
ll hd[maxn],head[maxn],step[maxn],dis[maxn],vis[maxn];
struct Edge{
    ll u,v,val,next;
}edge[maxm<<1];
struct E{
    ll v,next,fl;
}e[maxm<<2];
inline ll read()
{
    ll x=0,f=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';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=0 ,e[cnt].next=head[u],head[u]=cnt;
}

void SPFA()
{
    queue<ll> que;
    memset(dis,63,sizeof(dis));
    dis[1]=0,que.push(1);
    RG u,v;
    while(!que.empty())
    {
        u=que.front(),que.pop();vis[u]=0;
        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]=1,que.push(v);
            }
        }
    }
}

ll bfs()
{
    queue<ll> que;
    memset(step,-1,sizeof(step));step[S]=0,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>0&&step[v]==-1)
                step[v]=step[u]+1,que.push(v);
        }
    }
    return (step[T]!=-1);
}

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]+1&&e[i].fl>0)
        {
            ll fl=dfs(v,min(rem,e[i].fl));
            e[i].fl-=fl,e[i^1].fl+=fl;
            rem-=fl;
            if(!rem)    break;
        }
    }
    if(rem)    step[u]=-1;
    return res-rem;
}

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

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