题目描述

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

比荷卢经济联盟有很多公交线路。每天公共汽车都会从一座城市开往另一座城市。沿途汽车可能会在一些城市（零或更多）停靠。

旅行社计划旅途从 $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$。

样例 #1

样例输入 #1

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

样例输出 #1

3
2

提示

【数据范围】

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

算法思想

根据题目描述，求的是从 $S$ 城市出发、到 $F$ 城市结束的所有路线中，最短路、或者仅比最小路程多$1$个单位长度的次短路的方案数。

在博主的另一篇文章每周一算法：最短路计数介绍过，可以使用动态规划的思想，定义状态$f[i]$表示起点到顶点$i$的最短路的方案数。为了能同时求出次短路的方案数，可以采用拆点的思想：

• 用$f[i][0]$表示起点到顶点$i$的最短路的方案数
• 用$f[i][1]$表示起点到顶点$i$的次短路的方案数

与最短路计数一样，图中有可能存在环，不一定存在拓扑序列，因此不能通过循环迭代直接计算状态；可以使用最短路算法，在计算最短路的同时将状态计算出来。同时，在计算最短路时，能够找到一个拓扑序来计算状态。这样就需要最短路算法能够构造出一个最短路拓扑图，如下图所示：

由于边权不相同，这里可以用Dijkstra算法求最短路。Dijkstra算法计算最短路时，每个点只会出队$1$次，当一个点出队时，是不会更新前面已经出队的点到起点的最短路，因此出队序列满足拓扑序。

算法流程

• 将起点$S$的最短路初始化为$0$，即$dis[S][0]=0$；方案数初始化为$1$，即$f[S][0]=1$；
• 在求解最短路的过程中
  • 当$v$点到起点的最短路能够被点松弛：
    • 将之前的最短路变为次短路，更新次短路的方案数
    • 更新最短路的长度，设置最短路的方案数
  • 当$v$点到起点的最短路等于经过$u$点中转的距离，累加最短路的方案数
  • 当$v$点到起点的次短路能够被点松弛：
    • 更新次短路的长度，设置次短路的方案数
  • 当$v$点到起点的次短路等于经过$u$点中转的距离，累加次短路的方案数
• 最后，如果次短路的长度$+1$等于最短路长度，即$dis[F][1]=dis[F][0]+1$，那么总方案数为 $f[F][0]+f[F][1]$；否则，总方案数为 $f[F][0]$。

代码实现

#include <bits/stdc++.h>
using namespace std;
const int N = 1005, M = 1e4 + 5;
int h[N], e[M], w[M], ne[M], idx; 
int n, m, S, F;
int dis[N][2], f[N][2]; //f[i][0]表示到i点最短路条数
bool st[N][2];
struct V {
    int ver, type, dis; //节点、类型（0最短路、1次短路）、到起点距离
    bool operator > (const V &v) const //小顶堆，重载 > 
    {
        return dis > v.dis;
    }
};
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
int dijkstra()
{
    memset(st, 0, sizeof st);
    memset(dis, 0x3f, sizeof dis);
    memset(f, 0, sizeof f);
    dis[S][0] = 0, f[S][0] = 1; //初始化最短路和条数
    priority_queue<V, vector<V>, greater<V>> q; //小顶堆
    q.push({S, 0, 0}); //起点最短路入堆
    while(q.size())
    {
        V t = q.top(); q.pop();
        int u = t.ver, type = t.type, d = t.dis, cnt = f[u][type];
        if(st[u][type]) continue;
        st[u][type] = true;
        
        for(int i = h[u]; ~ i; i = ne[i])
        {
            int v = e[i];
            if(dis[v][0] > d + w[i]) //可以更新最短路
            {
                dis[v][1] = dis[v][0], f[v][1] = f[v][0]; //最短路变次短路，同时更新次短路个数
                q.push({v, 1, dis[v][1]}); //次短路入堆
                dis[v][0] = d + w[i], f[v][0] = cnt; //更新最短路以及最短路个数
                q.push({v, 0, dis[v][0]});
            }
            else if(dis[v][0] == d + w[i]) //与最短路相等
            {
                f[v][0] += cnt; //累加最短路个数
            }
            else if(dis[v][1] > d + w[i]) //可以更新次短路
            {
                dis[v][1] = d + w[i], f[v][1] = cnt;
                q.push({v, 1, dis[v][1]});
            }
            else if(dis[v][1] == d + w[i]) //与次短路相等
            {
                f[v][1] += cnt;
            }
        }
    }
    int ans = f[F][0]; //最短路个数
    if(dis[F][1] == dis[F][0] + 1) //次短路等于最短路+1
        ans += f[F][1];
    return ans;
}
int main()
{
    int T;
    scanf("%d", &T);
    while(T --)
    {
        scanf("%d%d", &n, &m);
        memset(h, -1, sizeof h);
        idx = 0;
        while(m --)
        {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            add(a, b, c);
        }
        scanf("%d%d", &S, &F);
        printf("%d\n", dijkstra());
    }
    return 0;
}