Marriage Match IV 最短路 + 网络流

传送门

分析

这道题比较有意思
题意是说给定n节点，m单向带权边，从s到t，只能走最短路，每条路只能走一次，请问最多能到达t几次（不用从t返回s）

我们可以首先跑两次spfa，然后对每条边进行判断，如果这个边起点到汇点的最短距离加上这条边终点到聚点的最短距离加上这条边的长度再加上这条边的长度恰好等于汇点到聚点的最短路的话，那么我门就把这条边加入流网络，流量为1，最后建完图跑一下dinic即可

代码

#include <iostream>
#include <cstring>
#include <queue>
#include <cstdio>

using namespace std;

const int N = 1010,M = 100010 * 2;
const int INF = 0x3f3f3f3f;

int h1[N],ne1[M],e1[M],w1[M],idx1;
int h2[N],ne2[M],e2[M],w2[M],idx2;
int h[N],ne[M],e[M],f[M],idx;
int d1[N],d2[N];
int q[N],d[N],cur[N];
bool st[N];
int S,E;
int n,m;

void add1(int x,int y,int z){
    w1[idx1] = z,ne1[idx1] = h1[x],e1[idx1] = y,h1[x] = idx1++;
}

void add2(int x,int y,int z){
    w2[idx2] = z,ne2[idx2] = h2[x],e2[idx2] = y,h2[x] = idx2++;
}

void add(int x,int y,int z){
    f[idx] = z,ne[idx] = h[x],e[idx] = y,h[x] = idx++;
    e[idx] = x,ne[idx] = h[y],f[idx] = 0,h[y] = idx++;
}

void init(){
    memset(h1,-1,sizeof h1);
    memset(h2,-1,sizeof h2);
    memset(h,-1,sizeof h);
    memset(d1,0x3f,sizeof d1);
    memset(d2,0x3f,sizeof d2);
    idx1 = 0;
    idx2 = 0;
    idx = 0;
}

void spfa1(){
    queue<int> Q;
    Q.push(S);
    d1[S] = 0;
    while(!Q.empty()){
        int t = Q.front();
        Q.pop();
        st[t] = false;
        for(int i = h1[t];~i;i = ne1[i]){
            int j = e1[i];
            if(d1[j] > d1[t] + w1[i]){
                d1[j] = d1[t] + w1[i];
                if(!st[j]){
                    Q.push(j);
                    st[j] = true;
                }
            }
        }
    }
}

void spfa2(){
    queue<int> Q;
    Q.push(E);
    d2[E] = 0;
    while(!Q.empty()){
        int t = Q.front();
        Q.pop();
        st[t] = false;
        for(int i = h2[t];~i;i = ne2[i]){
            int j = e2[i];
            if(d2[j] > d2[t] + w2[i]){
                d2[j] = d2[t] + w2[i];
                if(!st[j]){
                    Q.push(j);
                    st[j] = true;
                }
            }
        }
    }
}

bool bfs(){
    queue<int> Q;
    Q.push(S);
    memset(d,-1,sizeof d);
    d[S] = 0;
    cur[S] = h[S];
    while(!Q.empty()){
        int t = Q.front();
        Q.pop();
        for(int i = h[t];~i;i = ne[i]){
            int j = e[i];
            if(d[j] == -1 && f[i]){
                d[j] = d[t] + 1;
                cur[j] = h[j];
                if(j == E) return true;
                Q.push(j);
            }
        }
    }
    return false;
}

int find(int u,int limit){
    if(u == E) return limit;
    int flow = 0;
    for(int i = cur[u];~i && flow < limit;i = ne[i]){
        cur[u] = i;
        int j = e[i];
        if(d[j] == d[u] + 1 && f[i]){
            int t = find(j,min(f[i],limit - flow));
            if(!t) d[j] = -1;
            f[i] -= t,f[i ^ 1] +=t,flow += t;
        }
    }
    return flow;
}

int dinic(){
    int r = 0,flow;
    while(bfs()) while(flow = find(S,INF)) r += flow;
    return r;
}


int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        init();
        scanf("%d%d",&n,&m);
        for(int i = 0;i < m;i++){
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            add1(x,y,z);
            add2(y,x,z);
        }
        scanf("%d%d",&S,&E);
        spfa1();
        spfa2();
        for(int i = 0;i < m;i++){
            int x = e1[i],y = e2[i];
            if(d1[y] + d2[x] + w1[i] == d1[E]){
                add(y,x,1);
            }
        }
        printf("%d\n",dinic());
    }
    return 0;
}