[bzoj3931][网络流][最短路]网络吞吐量

最新推荐文章于 2021-08-12 22:44:37 发布

原创最新推荐文章于 2021-08-12 22:44:37 发布 · 278 阅读

0 ·

CC 4.0 BY-SA版权

bzoj 同时被 3 个专栏收录

483 篇文章

订阅专栏

网络流

35 篇文章

订阅专栏

最长/短路

20 篇文章

订阅专栏

本文介绍了一种结合路由算法和网络流技术的方法，用于计算从路由器1到路由器n的网络最大吞吐量。通过SPFA算法寻找最短路径，并利用网络流算法优化路径上的数据包转发效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

题解

半个月没打代码的辣鸡手感导致打错模版。。
原图SPFA之后最短路上重建图跑网络流，记得拆点。。
判一条边能构成最短路，设这条边连的点是u,v
d[u]+edge.c=d[v]，该边能构成最短路
之后u拆点v拆点，u出的点连向v进的点。。流量INF
输入的吞吐量拆点，u进的点连向u出的点，流量为给出的值
INF要开大点。。因为这个10^9

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;
typedef long long LL;
const LL INF=1000000000000000LL;
struct node
{
    int x,y,next,other;
    LL c;
}a[1110000];int len,last[210000];
struct edge{int x,y;LL c;}e[110000];
void ins(int x,int y,LL c)
{
    len++;
    a[len].x=x;a[len].y=y;a[len].c=c;
    a[len].next=last[x];last[x]=len;
}
void insx(int x,int y,LL c)
{
    int k1,k2;
    k1=++len;
    a[len].x=x;a[len].y=y;a[len].c=c;
    a[len].next=last[x];last[x]=len;
    k2=++len;
    a[len].x=y;a[len].y=x;a[len].c=0;
    a[len].next=last[y];last[y]=len;
    a[k1].other=k2;a[k2].other=k1;
}
int list[51000],n,m;
LL d[1100];
int head,tail;
bool v[1100];
queue<int> q;
void SPFA()
{
    memset(v,false,sizeof(v));v[1]=true;
    for(int i=1;i<=n;i++)d[i]=INF;d[1]=0;
    q.push(1);
    while(!q.empty())
    {
        int x=q.front();
        for(int k=last[x];k;k=a[k].next)
        {
            int y=a[k].y;
            if(d[y]>d[x]+a[k].c)
            {
                d[y]=d[x]+a[k].c;
                if(v[y]==false)
                {
                    v[y]=true;
                    q.push(y);
                }
            }
        }
        q.pop();
        v[x]=false;
    }
}
void build()
{
    len=0;memset(last,0,sizeof(last));
    for(int i=1;i<=m;i++)
    {
        int x=e[i].x,y=e[i].y;
        if(d[x]+e[i].c==d[y])insx(x+n,y,INF);
        if(d[y]+e[i].c==d[x])insx(y+n,x,INF);
    }
}
int h[1100],st,ed;
bool bt_h()
{
    memset(h,0,sizeof(h));h[st]=1;
    list[1]=st;head=1;tail=2;
    while(head!=tail)
    {
        int x=list[head];
        for(int k=last[x];k;k=a[k].next)
        {
            int y=a[k].y;
            if(a[k].c>0 && h[y]==0)
            {
                h[y]=h[x]+1;
                list[tail++]=y;
            }
        }
        head++;
    }
    if(h[ed]>0)return true;
    return false;
}
LL findflow(int x,LL f)
{
    if(x==ed)return f;
    LL s=0,t;
    for(int k=last[x];k;k=a[k].next)
    {
        int y=a[k].y;
        if(h[y]==h[x]+1 && a[k].c>0 && s<f)
        {
            s+=(t=findflow(y,min(a[k].c,f-s)));
            a[k].c-=t;a[a[k].other].c+=t;
        }
    }
    if(s==0)h[x]=0;
    return s;
}
int main()
{
    scanf("%d%d",&n,&m);
    len=0;memset(last,0,sizeof(last));
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%lld",&e[i].x,&e[i].y,&e[i].c);
        ins(e[i].x,e[i].y,e[i].c);ins(e[i].y,e[i].x,e[i].c);
    }
    SPFA();
    build();
    for(int i=1;i<=n;i++)
    {
        LL tmp;
        scanf("%lld",&tmp);
        if(i!=1 && i!=n)insx(i,i+n,tmp);
    }
    st=n*2+1;ed=n*2+2;
    insx(1,1+n,INF);insx(n,n+n,INF);
    insx(st,1,INF);insx(n+n,ed,INF);
    LL ans=0;
    while(bt_h())ans+=findflow(st,INF);
    printf("%lld\n",ans);
    return 0;
}