<—点个赞吧QwQ

宣传一下算法提高课整理

“您的个人假期”旅行社组织了一次比荷卢经济联盟的巴士之旅。

比荷卢经济联盟有很多公交线路。

每天公共汽车都会从一座城市开往另一座城市。

沿途汽车可能会在一些城市（零或更多）停靠。

旅行社计划旅途从 $S$ 城市出发，到 $F$ 城市结束。

由于不同旅客的景点偏好不同，所以为了迎合更多旅客，旅行社将为客户提供多种不同线路。

游客可以选择的行进路线有所限制，要么满足所选路线总路程为 $S$ 到 $F$ 的最小路程，要么满足所选路线总路程仅比最小路程多一个单位长度。

如上图所示，如果 $S = 1，F = 5$，则这里有两条最短路线 $1 \\to 2 \\to 5,1 \\to 3 \\to 5$，长度为 $6$；有一条比最短路程多一个单位长度的路线 $1 \\to 3 \\to 4 \\to 5$，长度为 $7$。

现在给定比荷卢经济联盟的公交路线图以及两个城市 $S$ 和 $F$，请你求出旅行社最多可以为旅客提供多少种不同的满足限制条件的线路。

输入格式

第一行包含整数 $T$，表示共有 $T$ 组测试数据。

每组数据第一行包含两个整数 $N$ 和 $M$，分别表示总城市数量和道路数量。

接下来 $M$ 行，每行包含三个整数 $A,B,L$，表示有一条线路从城市 $A$ 通往城市 $B$，长度为 $L$。

需注意，线路是 单向的，存在从 $A$ 到 $B$ 的线路不代表一定存在从 $B$ 到 $A$ 的线路，另外从城市 $A$ 到城市 $B$ 可能存在多个不同的线路。

接下来一行，包含两个整数 $S$ 和 $F$，数据保证 $S$ 和 $F$ 不同，并且 $S、F$ 之间至少存在一条线路。

输出格式

每组数据输出一个结果，每个结果占一行。

数据保证结果不超过 $10^9$。

数据范围

$2 \\le N \\le 1000$,
$1 \\le M \\le 10000$,
$1 \\le L \\le 1000$，
$1 \\le A,B,S,F \\le N$

输入样例：

2
5 8
1 2 3
1 3 2
1 4 5
2 3 1
2 5 3
3 4 2
3 5 4
4 5 3
1 5
5 6
2 3 1
3 2 1
3 1 10
4 5 2
5 2 7
5 2 7
4 1

输出样例：

3
2

思路

此题和前一题类似，只要多统计一下次短路的数量即可。
更新次短路时和更新次大值的代码类似。

代码

#include <iostream>
#include <cstring>
#include <queue>
#define type first
#define id second
using namespace std;
typedef pair <int,int> PII;
const int N = 1010,M = 20010;
int n,m,s,t;
int h[N],e[M],ne[M],w[M],idx;
int dist[2][N];
int cnt[2][N];
bool st[2][N];
void add (int a,int b,int c) {
    e[idx] = b;
    w[idx] = c;
    ne[idx] = h[a];
    h[a] = idx++;
}
struct cmp {
    bool operator ()(PII x,PII y) {
        return dist[x.type][x.id] > dist[y.type][y.id];
    }
};
void dijkstra () {
    memset (st,false,sizeof (st));
    memset (dist,0x3f,sizeof (dist));
    memset (cnt,0,sizeof (cnt));
    dist[0][s] = 0,cnt[0][s] = 1;
    priority_queue <PII,vector <PII>,cmp> heap;
    heap.push ({0,s});
    while (heap.size ()) {
        auto [type,t] = heap.top ();
        heap.pop ();
        if (st[type][t]) continue;
        st[type][t] = true;
        for (int i = h[t];~i;i = ne[i]) {
            int j = e[i],d = dist[type][t] + w[i],c = cnt[type][t];
            if (d < dist[0][j]) {
                dist[1][j] = dist[0][j],cnt[1][j] = cnt[0][j];
                heap.push ({1,j});
                dist[0][j] = d,cnt[0][j] = c;
                heap.push ({0,j});
            }
            else if (d == dist[0][j]) cnt[0][j] += c;
            else if (d < dist[1][j]) {
                dist[1][j] = d,cnt[1][j] = c;
                heap.push ({1,j});
            }
            else if (d == dist[1][j]) cnt[1][j] += c;
        }
    }
}
int main () {
    int T;
    cin >> T;
    while (T--) {
        memset (h,-1,sizeof (h));
        idx = 0;
        cin >> n >> m;
        while (m--) {
            int a,b,c;
            cin >> a >> b >> c;
            add (a,b,c);
        }
        cin >> s >> t;
        dijkstra ();
        int ans = cnt[0][t];
        if (dist[1][t] == dist[0][t] + 1) ans += cnt[1][t];
        cout << ans << endl;
    }
    return 0;
}