bzoj千题计划136：bzoj3931: [CQOI2015]网络吞吐量

http://www.lydsy.com/JudgeOnline/problem.php?id=3931

在最短路网络上跑最大流

#include<queue>

#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long LL;

const LL inf=1e16;

void read(int &x)

{

    x=; char c=getchar();

    while(!isdigit(c))  c=getchar();

    while(isdigit(c)) { x=x*+c-''; c=getchar();  }

}

struct NetworkFlow

{

    #define N 1100

    #define M 260000

    int tot;

    int front[N],nxt[M<<],to[M<<],from[M<<];

    LL val[M<<];

    int lev[N],num[N];

    int path[N];

    int cur[N];

    int src,decc;

    int cap[];

    /*int se[501];

    int edge[501][501];*/

    void add(int u,int v,LL w)

    {

        to[++tot]=v; nxt[tot]=front[u]; front[u]=tot; from[tot]=u; val[tot]=w;

        to[++tot]=u; nxt[tot]=front[v]; front[v]=tot; from[tot]=v; val[tot]=;

    }

    bool bfs()

    {

        queue<int>q;

        for(int i=src;i<=decc;++i) lev[i]=decc-src+;

        q.push(decc);

        lev[decc]=;

        int now,t;

        while(!q.empty())

        {

            now=q.front();

            q.pop();

            for(int i=front[now];i;i=nxt[i])

            {

                t=to[i];

                if(lev[t]==decc-src+ && val[i^])

                {

                    lev[t]=lev[now]+;

                    q.push(t);

                }

            }

        }

        return lev[src]!=decc-src+;

    }

    int augment()

    {

        int now=decc;

        LL flow=inf;

        int i;

        while(now!=src)

        {

            i=path[now];

            flow=min(flow,val[i]);

            now=from[i];

        }

        now=decc;

        while(now!=src)

        {

            i=path[now];

            val[i]-=flow;

            val[i^]+=flow;

            now=from[i];

        }

        return flow;

    }

    LL isap()

    {

        LL flow=;

        if(!bfs()) return ;

        memset(num,,sizeof(num));

        for(int i=src;i<=decc;++i) num[lev[i]]++,cur[i]=front[i];

        int now=src,t;

        while(lev[src]<=decc-src)

        {

            if(now==decc)

            {

                flow+=augment();

                now=src;

            }

            bool advanced=false;

            for(int i=cur[now];i;i=nxt[i])

            {

                t=to[i];

                if(lev[t]==lev[now]- && val[i])

                {

                    advanced=true;

                    path[t]=i;

                    cur[now]=i;

                    now=t;

                    break;

                }

            }

            if(!advanced)

            {

                int mi=decc;

                for(int i=front[now];i;i=nxt[i])

                    if(val[i]) mi=min(mi,lev[to[i]]);

                if(!--num[lev[now]]) break;

                num[lev[now]=mi+]++;

                cur[now]=front[now];

                if(now!=src) now=from[path[now]];

            }

        }

        return flow;

    }

    void build(int n)

    {

        //for(int i=1;i<=n;++i) cout<<se[i]<<'\n';

        src=;

        decc=n<<;

        for(int i=;i<n;++i) add(i<<,i<<|,cap[i]);

        /*for(int i=1;i<=n;++i)

        {

            for(int j=1;j<=se[i];++j)

                add(i<<1|1,edge[i][j]<<1,inf);

        }*/

    }

    #undef N

    #undef M

}Net;

struct Graph

{

    #define N 501

    #define M 100001

    int tot;

    int front[N],to[M<<],nxt[M<<],val[M<<],from[M<<];

    LL DIS[N];

    bool vis[N];

    struct node

    {

        LL dis;

        int id;

        bool operator < (node p) const

        {

            return dis>p.dis;

        }

    }cur,nt;

    void add(int u,int v,int w)

    {

        to[++tot]=v; nxt[tot]=front[u]; front[u]=tot; val[tot]=w; from[tot]=u;

        to[++tot]=u; nxt[tot]=front[v]; front[v]=tot; val[tot]=w; from[tot]=v;

    }

    void dijkstra(int n)

    {

        memset(DIS,,sizeof(DIS));

        DIS[n]=;

        priority_queue<node>q;

        cur.dis=;

        cur.id=n;

        q.push(cur);

        while(!q.empty())

        {

            cur=q.top();

            q.pop();

            if(DIS[cur.id]!=cur.dis) continue;

            for(int i=front[cur.id];i;i=nxt[i])

            {

                if(DIS[to[i]]>DIS[cur.id]+val[i])

                {

                    DIS[to[i]]=DIS[cur.id]+val[i];

                    nt.dis=DIS[to[i]];

                    nt.id=to[i];

                    q.push(nt);

                }

            }

        }

    }

    void build()

    {

        Net.tot=;

        for(int i=;i<=tot;++i)

        {

            if(DIS[from[i]]-val[i]==DIS[to[i]])

            {

                //cout<<from[i]<<' '<<to[i]<<'\n';

                Net.add(from[i]<<|,to[i]<<,inf);

            }

        }

    }

    #undef N

    #undef M

}G;

int main()

{

    //freopen("cqoi15_network.in","r",stdin);

    //freopen("cqoi15_network.out","w",stdout);

    int n,m;

    read(n); read(m);

    int u,v,w;

    while(m--)

    {

        read(u); read(v); read(w);

        G.add(u,v,w);

    }

    for(int i=;i<=n;++i) read(Net.cap[i]);

    G.dijkstra(n);

    //cout<<G.DIS[1]<<'\n';

    G.build();

    Net.build(n);

    cout<<Net.isap();

}

3931: [CQOI2015]网络吞吐量

Time Limit: 10 Sec Memory Limit: 512 MB
Submit: 2094 Solved: 873
[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

HINT

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