Marriage Match IV HDU - 3416 (最短路径包含的边 + 最大流)

最新推荐文章于 2021-05-12 09:08:10 发布

原创最新推荐文章于 2021-05-12 09:08:10 发布 · 249 阅读

0 ·

CC 4.0 BY-SA版权

最短路同时被 2 个专栏收录

13 篇文章

订阅专栏

网络流

10 篇文章

订阅专栏

本文介绍了一种基于最短路径算法的边匹配方法，通过从起点和终点分别计算最短路径，找出所有可能的最短路径组合。利用Dijkstra算法和最大流算法，文章详细解释了如何确定哪些边属于最短路径，并最终计算出从起点到终点的最短路径数量。

Marriage Match IV

题意：给定一张图，起点 s，终点 t，每条路只能走一次，问从s 到 t 的最短路径有几种

思路：先寻找最短路径中的可行边。寻找方法是，先从s 跑一边最短路，记数组为 dis1, 从t 跑一边反向图的最短路，记数组为dis2。对于每一条边，如果 dis1[u] + dis2[v] + w == dis1[t] ，这条边就在最短路径上。。。对于每一条可行边，其容量都是1，跑一边最大流，即是ans。注意：如果你是用矩阵跑dinic，每一次都是边的容量 ++

代码：

#include<bits/stdc++.h>
#define debug(x) cout << "[" << #x <<": " << (x) <<"]"<< endl
#define pii pair<int,int>
#define clr(a,b) memset((a),b,sizeof(a))
#define rep(i,a,b) for(int i = a;i < b;i ++)
#define pb push_back
#define MP make_pair
#define LL long long
#define INT(t) int t; scanf("%d",&t)
#define LLI(t) LL t; scanf("%I64d",&t)

using namespace std;

const int maxn = 1e3 + 10;
const int inf = 0x3f3f3f3f;
struct xx {
    int u, v, nex, w;
    xx() {}
    xx(int u, int v, int nex, int w):
        u(u), v(v), nex(nex), w(w) {}
} edge[maxn * 100];
int head[maxn];
int dis1[maxn];
int dis2[maxn];
int cnt;
int c[maxn][maxn];
int dep[maxn];

void init() {
    for(int i = 0; i < maxn; i ++) {
        head[i] = -1;
        dis1[i] = dis2[i] = inf;
        cnt = 0;
    }
    clr(c, 0);
}

void dij(int x, int *dis) {
    dis[x] = 0;
    priority_queue<pair<int, int> > Q;
    Q.push(MP(-dis[x], x));
    while(!Q.empty()) {
        int now = Q.top().second;
        Q.pop();
        for(int i = head[now]; ~i; i = edge[i].nex) {
            int v = edge[i].v;
            int d = edge[i].w;
            if(dis[v] > dis[now] + d) {
                dis[v] = dis[now] + d;
                Q.push(MP(-dis[v], v));
            }
        }
    }
}

int bfs(int s, int t,int m) { //重新建图，按层次建图
    queue<int> q;
    while(!q.empty())
        q.pop();
    memset(dep, -1, sizeof(dep));
    dep[s] = 0;
    q.push(s);
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        for(int v = 1; v <= m; v++) {
            if(c[u][v] > 0 && dep[v] == -1) { //如果可以到达且还没有访问，可以到达的条件是剩余容量大于0，没有访问的条件是当前层数还未知
                dep[v] = dep[u] + 1;
                q.push(v);
            }
        }
    }
    return dep[t] != -1;
}

int dfs(int u, int mi, int t,int m) { //查找路径上的最小流量
    if(u == t)
        return mi;
    for(int v = 1; v <= m; v++) {
        if(c[u][v] > 0 && dep[v] == dep[u] + 1) {
            int tmp = dfs(v, min(mi, c[u][v]), t, m);
            if(tmp > 0) {
                c[u][v] -= tmp;
                c[v][u] += tmp;
                return tmp;
            }
        }
    }
    return 0;
}
int dinic(int s, int t,int m) {
    int ans = 0, tmp;
    while(bfs(s, t, m)) {
        while(1) {
            tmp = dfs(s, inf, t, m);
            if(tmp == 0)
                break;
            ans += tmp;
        }
    }
    return ans;
}

int main() {
    int t;
    scanf("%d", &t);
    while(t --) {
        init();
        int n, m;
        scanf("%d%d", &n, &m);
        for(int i = 0; i < m; i ++) {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            edge[cnt] = xx(a, b, head[a], c);
            head[a] = cnt ++;
        }
        int A, B;
        scanf("%d%d", &A, &B);
        dij(A, dis1);
        for(int i = 0; i < maxn; i ++)
            head[i] = -1;
        cnt = 0;
        for(int i = 0; i < m; i ++) {
            int u = edge[i].u;
            int v = edge[i].v;
            int w = edge[i].w;
            edge[i] = xx(v, u, head[v], w);
            head[v] = cnt ++;
        }
        dij(B, dis2);
        for(int i = 0; i < m; i ++) {
            int u = edge[i].u;
            int v = edge[i].v;
            int w = edge[i].w;
            if(dis1[v] + dis2[u] + w == dis1[B])
                c[v][u] ++;
        }
        printf("%d\n", dinic(A, B, n));
    }
    return 0;
}