BZOJ 3931 [CQOI2015]网络吞吐量：最大流【拆点】

传送门

题意

给你一个 $ n $ 个点，$ m $ 条边的无向网络，每条边有长度。每个点的流量限制为 $ c[i] $ 。

要求流量只能经过从 $ 1 $ 的 $ n $ 的最短路。问你最大流是多少。

题解

先以 $ 1 $ 和 $ n $ 分别为起点跑一遍dijkstra，判断出哪些边是在最短路上的。

将每个点 $ i $ 拆成两个点 $ A(i), B(i) $ ，从 $ A(i) $ 向 $ B(i) $ 连一条容量为 $ c[i] $ 的边。

对于每条在最短路上的边 $ i \to j $ ，从 $ B(i) $ 向 $ A(j) $ 连一条容量为 $ INF $ 的边。

最后从 $ B(1) $ 到 $ A(n) $ 跑一遍最大流就好。

AC Code

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <queue>
#define MAX_N 1005
#define MAX_M 100005
#define INF 100000000000000ll
#define A(x) (x)
#define B(x) (n+(x))
#define int long long

using namespace std;

struct Ed
{
    int dst,len;
    Ed(int _dst,int _len) { dst=_dst,len=_len; }
    Ed(){}
};

struct Data
{
    int x,w;
    Data(int _x,int _w) { x=_x,w=_w; }
    Data(){}
    friend bool operator < (const Data &a,const Data &b)
    {
        return a.w>b.w;
    }
};

struct Edge
{
    int dst,cap,rev;
    Edge(int _dst,int _cap,int _rev) { dst=_dst,cap=_cap,rev=_rev; }
    Edge(){}
};

int n,m,tot;
int a[MAX_M];
int b[MAX_M];
int c[MAX_M];
int d[MAX_N];
int dis[MAX_N];
int rev[MAX_N];
bool vis[MAX_N];
int it[MAX_N];
int lv[MAX_N];
vector<Ed> ed[MAX_N];
priority_queue<Data> Q;
vector<Edge> edge[MAX_N];
queue<int> q;

void read()
{
    scanf("%lld%lld",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%lld%lld%lld",&a[i],&b[i],&c[i]);
        ed[a[i]].push_back(Ed(b[i],c[i]));
        ed[b[i]].push_back(Ed(a[i],c[i]));
    }
    for(int i=1;i<=n;i++) scanf("%lld",&d[i]);
}

void dij(int s,int *dis)
{
    memset(dis+1,0x3f,sizeof(int)*n);
    memset(vis+1,false,sizeof(bool)*n);
    dis[s]=0,Q.push(Data(s,0));
    while(!Q.empty())
    {
        int x=Q.top().x; Q.pop();
        if(vis[x]) continue; vis[x]=true;
        for(int i=0;i<ed[x].size();i++)
        {
            Ed temp=ed[x][i];
            if(dis[temp.dst]>dis[x]+temp.len)
            {
                dis[temp.dst]=dis[x]+temp.len;
                Q.push(Data(temp.dst,dis[temp.dst]));
            }
        }
    }
}

inline void add(int s,int t,int c)
{
    edge[s].push_back(Edge(t,c,edge[t].size()));
    edge[t].push_back(Edge(s,0,edge[s].size()-1));
}

void build()
{
    tot=(n<<1);
    for(int i=2;i<n;i++) add(A(i),B(i),d[i]);
    for(int i=1;i<=m;i++)
    {
        if(dis[a[i]]+c[i]+rev[b[i]]==dis[n]) add(B(a[i]),A(b[i]),INF);
        if(dis[b[i]]+c[i]+rev[a[i]]==dis[n]) add(B(b[i]),A(a[i]),INF);
    }
}

void bfs(int s)
{
    memset(lv+1,0,sizeof(int)*tot);
    lv[s]=1,q.push(s);
    while(!q.empty())
    {
        int x=q.front(); q.pop();
        for(int i=0;i<edge[x].size();i++)
        {
            Edge temp=edge[x][i];
            if(temp.cap>0 && !lv[temp.dst])
            {
                lv[temp.dst]=lv[x]+1;
                q.push(temp.dst);
            }
        }
    }
}

int dfs(int x,int t,int f)
{
    if(x==t) return f;
    for(int &i=it[x];i<edge[x].size();i++)
    {
        Edge &temp=edge[x][i];
        if(temp.cap>0 && lv[x]<lv[temp.dst])
        {
            int d=dfs(temp.dst,t,min(f,temp.cap));
            if(d>0)
            {
                temp.cap-=d;
                edge[temp.dst][temp.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}

int max_flow(int s,int t)
{
    int ans=0,f;
    while(true)
    {
        bfs(s);
        if(!lv[t]) return ans;
        memset(it+1,0,sizeof(int)*tot);
        while((f=dfs(s,t,INF))>0) ans+=f;
    }
}

void work()
{
    dij(1,dis);
    dij(n,rev);
    build();
    printf("%lld\n",max_flow(B(1),A(n)));
}

signed main()
{
    read();
    work();
}

转载于:https://www.cnblogs.com/Leohh/p/9175507.html