BZOJ3931 CQOI2015 网络吞吐量

最短路生成图上跑最大流

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<vector>

using namespace std;

#define dout printf

typedef long long ll;
const int Maxn=1010;
const ll INF=4557430888798830399ll;
int n,m,N;
ll g[Maxn][Maxn];
ll d[Maxn*2];
bool flag[Maxn];

struct Edge{
    int to;
    ll cap,flow;
    int next;
    Edge(int to=0,ll cap=0,int next=0):to(to),cap(cap),next(next){
        flow=0;
    }
    ll adv(){
        return cap-flow;
    }
}edges[2000010];int tot=1,fir[Maxn*2];

void AddEdge(int from,int to,ll cap){
    edges[++tot]=Edge(to,cap,fir[from]);fir[from]=tot;
    edges[++tot]=Edge(from,0,fir[to]);fir[to]=tot;
}

void init(){
    scanf("%d%d",&n,&m);N=2*n;
    memset(g,0x3f,sizeof g);
    for(int u,v,w,i=1;i<=m;i++){
        scanf("%d%d%d",&u,&v,&w);
        if(g[u][v]>w) g[u][v]=g[v][u]=w;
    }
    
    for(int c,i=1;i<=n;i++){
        scanf("%d",&c);
        AddEdge(i,i+n,(i==1||i==n)?INF:c);
    }
}

void Dijkstra(){
    memset(d,0x3f,sizeof d);
    memset(flag,0,sizeof flag);
    d[1]=0;
    ll MN;
    int u;
    for(int T=n;T--;){
        MN=INF;
        for(int i=1;i<=n;i++) if(!flag[i] && d[i]<MN) {
            MN=d[i]; u=i;
        }
        flag[u]=1;
        for(int i=1;i<=n;i++){
            d[i]=min(d[i],d[u]+g[u][i]);
        }
    }
}

int q[Maxn],ql,qr;
void build(){
    q[qr=(ql=0)+1]=n;
    memset(flag,0,sizeof flag);
    for(;ql<qr;){
        int u=q[++ql];
        for(int v=1;v<=n;v++)if(u!=v && d[v]+g[u][v]==d[u]){
            AddEdge(v+n,u,INF);
            if(!flag[v]) q[++qr]=v,flag[v]=1;
        }
    }
}

// network-flows begin----------------------------------------------
int s,t;
int p[Maxn*2],cur[Maxn*2],num[Maxn*2];
#define e edges[i]

inline ll Augment(){
    ll a=INF;
    for(int x=t;x!=s;x=edges[p[x]^1].to){
        a=min(a,edges[p[x]].adv());
    }
    for(int x=t;x!=s;x=edges[p[x]^1].to){
        edges[p[x]].flow+=a;
        edges[p[x]^1].flow-=a;
    }
    return a;
}
inline void BFS(int start,bool flag){
    for(int i=1;i<=N;i++)d[i]=N;
    d[q[qr=(ql=0)+1]=start]=0;
    for(int x;ql<qr;){
        x=q[++ql];
        for(int i=fir[x];i;i=e.next){
            if((flag^(bool)e.adv())&&d[e.to]==N){
                d[q[++qr]=e.to]=d[x]+1;
            }
        }
    }
}
inline ll ISAP(){
    s=1,t=N;
    BFS(t,1);
    ll flow=0;
    memcpy(cur,fir,sizeof cur);
    for(int i=1;i<=N;i++)num[d[i]]++;
    for(int i=1;i<=d[s];i++)if(!num[i])return 0;
    for(int x=s;d[s]<N;){
        if(x==t){
            flow+=Augment();
            x=s;
        }
        int ok=0;
        for(int&i=cur[x];i;i=e.next){
            if(e.adv()&&d[x]==d[e.to]+1){
                p[x=e.to]=i;
                ok=1;
                break;
            }
        }
        if(!ok){
            int M=N;
            for(int i=fir[x];i;i=e.next){
                if(e.adv())M=min(M,(int)d[e.to]+1);
            }
            if(!--num[d[x]])break;
            num[d[x]=M]++;
            cur[x]=fir[x];
            if(x!=s)x=edges[p[x]^1].to;
        }
    }
    return flow;
}
//network-flows end-----------------------------------------------------------

int main(){
    freopen("network.in","r",stdin);
    freopen("network.out","w",stdout);
    init();
    Dijkstra();
    build();
    cout<<ISAP();
    return 0;
}