AcWing 345 牛站 【BellmanFord算法，非正解】

$AcWing$ $345$ 牛站

题目传送门

一、题目描述

给定一张由 $T$ 条边构成的无向图，点的编号为 $1$∼$1000$ 之间的整数。

求从起点 $S$ 到终点 $E$ 恰好 经过 $N$ 条边（可以重复经过）的 最短路。

注意: 数据保证一定有解。

输入格式
第 $1$ 行：包含四个整数 $N$，$T$，$S$，$E$。

第 $2..T+1$ 行：每行包含三个整数，描述一条边的边长以及构成边的两个点的编号。

输出格式
输出一个整数，表示最短路的长度。

二、$bellmanFord$之恰好$k$条边

有边数限制的最短路径问题，第一反应自然是 $BellmanFord$算法，只需对$BellmanFord$算法的逻辑稍加修改，再吸吸氧应该就可以$AC$了

• $Bellman-Ford$算法求解经过不超过$k$条边的最短路

• $Bellman-Ford$算法求解经过恰好$k$条边的最短路（可以重复经过）

$BellmanFord$算法的存图方式比较牛$X$($yxc$大佬原话)，用一个结构体$Edge(u,v,w)$,然后开一个数组就行了，随便存，与之前学习的邻接表不同。

原因：因为$BellmanFord$需要 遍历每一条边，怎么能快速遍历每一条边就是关键。
以前学习过的邻接表，是按点做索引的 ，记录这个点出发到达哪些点。
如果采用邻接表，就需要枚举每个点，然后二次循环找出每条边，就麻烦了，不如直接以边为索引来的快了。

问题
$Q_1$:$bellmonFord$ 算法解决的问题是 最多 经过$k$条边的最短路，而题目问的是 恰好经过 $k$条边的最短路径，怎么解决呢？

$A$：$bellmonFord$ 每次 强制转移 即可，即把新的距离数组赋值为正无穷。
这样每迭代一次数组中$i$代表的一定是恰好走$k$步的步数。

$Q_2:$为什么要加上 备份数组 ？
$A$:每次在处理$dist$数组前备份一下到$backup$数组，是为了每次迭代只使用上一次的结果，本次的迭代结果不用于本轮次的其它迭代，这样才能保证使用边数的限制有效,就不会发生串联了。

#pragma GCC optimize(2)

#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
const int M = 1000010;
int dist[N], backup[N];
struct Edge {
    int a, b, c;
} edges[M];
int n, k, m, s, t;

int bellmanFord() {
    //初始化
    memset(dist, 0x3f, sizeof(dist));
    dist[s] = 0;

    //经过k次迭代
    for (int i = 0; i < k; i++) {
        memcpy(backup, dist, sizeof(dist)); //使用备份，防止串联
        memset(dist, 0x3f, sizeof(dist));   //这句是精髓，恰好需要在循环内进行全新初始化
        for (int j = 0; j < m; j++) {
            int a = edges[j].a, b = edges[j].b, c = edges[j].c;
            dist[b] = min(dist[b], backup[a] + c);
            dist[a] = min(dist[a], backup[b] + c);
        }
    }
    return dist[t];
}
int main() {
    scanf("%d %d %d %d", &k, &m, &s, &t);

    for (int i = 0; i < m; i++) {
        int a, b, c;
        scanf("%d %d %d", &c, &a, &b);
        edges[i].a = a, edges[i].b = b, edges[i].c = c;
    }
    printf("%d", bellmanFord());
    return 0;
}

三、离散化

本题没有离散化的必要！有的博文说必须需要离散化，纯粹是扯淡，人云亦云而已。

原因：

• $bellmanFord$是按边来枚举的，而且枚举的是$Edge$数组，不管你是不是离散化，边的数量都不会变化。
• 不超过$k$条 或者 恰好是$k$ 条,都是说$bellmanFord$的外层循环是$0 \sim k$,你离不离散化都没有影响。
• 非要说离散化有用的话，就是原来$993$这样的大号，被你搞成了$3$这样的小号，看着方便而已，其它毫无影响，该吸氧通过的，还得吸氧；该过不了的，还是过不了。
• 当然，只是说本题离散化没用，不是说图论的离散化没用，可别理解错了。

附上两种离散化的代码，起到学习的作用吧：

离散化技巧一

#pragma GCC optimize(2) //累了就吸点氧吧~不吸氧，通过8/12个数据

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 205, M = 105;
//现在看来，这个代码写的好垃圾啊，离散化用的不好。代码长
//而且，在用旧的号码记录到邻接表中，然后再去修改，逻辑太长，垃圾！
//相对于另外两套代码，都是在使用hashTable或者unordered_map进行映射后
//再放入邻接表(邻接矩阵)，就方便多了~
int m;    //图的边数
int k;    //恰好是k条边
int s, t; //起点和终点

struct Edge {
    int a; //起点
    int b; //终点
    int w; //边长
} edges[M];

int p[N]; //使用了哪些点，为了照顾后面的离散化，肯定要尽可能的把点都存储起来，
int tot;
int dist[N], backup[N];

//通过STL将原来的x找到现在新的下标位置
int get(int x) {
    int l = 0, r = tot;
    while (l < r) {
        int mid = (l + r) >> 1;
        if (p[mid] >= x)
            r = mid;
        else
            l = mid + 1;
    }
    return l;
}

int bellmanFord() {
    //最多经过 k 条边：在循环外初始化一次
    //恰好经过 k 条边：除在循环外初始化一次外,还需要在第一层循环中memcpy(backup)后面再次初始化
    memset(dist, 0x3f, sizeof dist);
    dist[s] = 0; //出发点

    //恰好是k条边，迭代k次
    for (int i = 0; i < k; i++) {
        memcpy(backup, dist, sizeof dist);
        memset(dist, 0x3f, sizeof dist);
        for (int j = 1; j <= m; j++) { //枚举m条边
            int a = edges[j].a, b = edges[j].b, w = edges[j].w;
            dist[b] = min(dist[b], backup[a] + w);
            dist[a] = min(dist[a], backup[b] + w);
        }
    }
    //计算在n条限定下的最短距离
    return dist[t];
}

int main() {
    //加快读入
    scanf("%d %d %d %d", &k, &m, &s, &t);

    for (int i = 1; i <= m; i++) {
        int a, b, c;
        scanf("%d %d %d", &c, &a, &b); //一条边的边长以及构成边的两个点的编号
        edges[i] = {a, b, c};
        //记录有哪些点，准备离散化去重
        p[tot++] = a, p[tot++] = b;
    }

    //离散化
    sort(p, p + tot);
    tot = unique(p, p + tot) - p;

    //枚举每条边，将第i条边的起点和终点转化为离散化后的新序号
    for (int i = 1; i <= m; i++)
        edges[i].a = get(edges[i].a), edges[i].b = get(edges[i].b);

    //将起点和终点也转化为离散化后的新点号
    s = get(s), t = get(t);

    //调用bellmanFord算法
    printf("%d\n", bellmanFord());
    return 0;
}

离散化技巧二

#pragma GCC optimize(2) //累了就吸点氧吧~

#include <bits/stdc++.h>
using namespace std;
int id[1010];
const int N = 210;
const int M = 1000010;
int d[N], backup[N];
struct Edge {
    int a, b, c;
} edges[M];
int n, k, m, s, t;

int bellmanFord() {
    memset(d, 0x3f, sizeof(d));
    d[s] = 0;
    for (int i = 0; i < k; i++) {
        memcpy(backup, d, sizeof(d));
        //与最多经过k条边这里不同！
        memset(d, 0x3f, sizeof(d));
        for (int j = 0; j < m; j++) {
            int a = edges[j].a, b = edges[j].b, c = edges[j].c;
            //与最多经过k条边这里不同！
            d[b] = min(d[b], backup[a] + c);
            d[a] = min(d[a], backup[b] + c);
        }
    }
    return d[t];
}
int main() {
    //加快读入
    scanf("%d %d %d %d", &k, &m, &s, &t);

    //起点分配1号
    if (!id[s]) id[s] = ++n;

    //结束结点为2号,为了防止起点和终点是一个，采用了判断的办法
    if (!id[t]) id[t] = ++n;

    //修改原来s和t的离散化后的值
    s = id[s], t = id[t];

    // m条边
    for (int i = 0; i < m; i++) {
        int a, b, c;
        scanf("%d %d %d", &c, &a, &b);
        if (!id[a]) id[a] = ++n;
        if (!id[b]) id[b] = ++n;
        edges[i].a = id[a], edges[i].b = id[b], edges[i].c = c;
    }
    //上面的离散化简直太牛B了！
    printf("%d", bellmanFord());
    return 0;
}