## [$AcWing$ $383$. 观光](https://www.acwing.com/problem/content/385/)

### 一、题目描述
**您的个人假期** 旅行社组织了一次比荷卢经济联盟的巴士之旅。

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

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

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

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

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

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

<center><img src='https://www.acwing.com/media/article/image/2019/02/26/19_75361c2839-3463_1.png'></center>

如上图所示，如果 $S=1，F=5$，则这里有两条最短路线 $1→2→5,1→3→5$，长度为 $6$；有一条比最短路程多一个单位长度的路线 $1→3→4→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≤N≤1000,1≤M≤10000,1≤L≤1000，1≤A,B,S,F≤N$

**输入样例**：
```cpp {.line-numbers}
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
```

**输出样例**：
```cpp {.line-numbers}
3
2
```

### 二、解题思路

本题是在 [$AcWing$ $1134$ 最短路计数](https://www.acwing.com/problem/content/1136/) 的扩展版本

要求求出起点$S$到终点$F$的 **最短** 和 **次短** 的路径的条数

#### 状态表示
我们发现在上一题的基础上，只用一维的$dist$和$cnt$数组并不能表示 **最短** 和 **次短** 两个状态,**所以多开一维**：

设状态$dist[i][0,1]$表示初始城市$S$到城市$i$的 **最短距离** 和 **次短距离**

$cnt[i][0,1]$表示城市$S$到城市$i$的最短路径和次短路经的 **条数**

**初始**
$dist[S][0]$=$0$，$cnt[S][0]$=$1$

#### 状态转移

枚举城市$u$可通往的城市$v$时，有四种情况：

##### $1$、 $dist[v][0]>dist[u][k]+w[i],k∈[0，1]$
 
  ① **更新最短路与次短路距离**
  - 当前 **最短路** 变为 **次短路**，然后更新 **最短路**
  - 将 **新变更** 的 **最短路** 和 **次短路** 加入优先队列
  
  ② **更新最短路和次短路条数**  
  - 到达$v$的最短路个数和到达$u$是一样的 : $cnt[v][0]=cnt[u][k]$

##### $2$、$dist[v][0]=dist[u][k]+w[i],k∈[0，1]$
  找到一条新的 **最短路**，更新最短路条数
到达$v$的最短路个数应该加上到达$u$的最短路个数，从$u$经过的最短路，在$v$上经过的时候也是最短路:$cnt[v][0]+=cnt[u][k]$

##### $3$、$dist[v][1]>dist[u][k]+w[i]$
  找到一条更短的次短路，覆盖掉当前次短路，加入优先队列
到达$v$的最短路个数和到达$u$是一样的 : $cnt[v][1]=cnt[u][k]$

##### $4$、$dist[v][1]=dist[u][k]+w[i]$ 
  找到一条新的次短路，**更新次短路条数**
到达$v$的最短路个数应该加上到达$u$的最短路个数，从$u$经过的最短路，在$v$上经过的时候也是最短路:$cnt[v][1]+=cnt[u][k]$


#### 特殊处理
最后到$F$城市的次短路径如果比最短路径恰好多$1$，满足题目要求，则把这样的路径条数加到答案里


### $Code$
```cpp {.line-numbers}
#include <bits/stdc++.h>
using namespace std;
#define x first
#define y second

const int N = 1e3 + 13;
const int M = 1e6 + 10;
int n, m, u, v, s, f;
// 将最短路扩展为二维，含义：最短路与次短路
// dis:路径长度,cnt：路线数量,st:是否已经出队列
int dis[N][2], cnt[N][2];
bool st[N][2];

// 链式前向星
int e[M], h[N], idx, w[M], ne[M];
void add(int a, int b, int c = 0) {
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}

struct Node {
    // u: 节点号
    // d:目前结点v的路径长度
    // k:是最短路0还是次短路1
    int u, d, k;
    const bool operator<(Node x) const {
        return d > x.d;
    }
};

void dijkrsta() {
    priority_queue<Node> q;        // 默认是大顶堆，通过定义结构体小于号，实现小顶堆。比如：认证的d值更大，谁就更小！
    memset(dis, 0x3f, sizeof dis); // 清空最小距离与次小距离数组
    memset(cnt, 0, sizeof cnt);    // 清空最小距离路线个数与次小距离路线个数数组
    memset(st, 0, sizeof st);      // 清空是否出队过数组

    cnt[s][0] = 1; // 起点s，0:最短路，1:有一条
    cnt[s][1] = 0; // 次短路，路线数为0

    dis[s][0] = 0; // 最短路从s出发到s的距离是0
    dis[s][1] = 0; // 次短路从s出发到s的距离是0

    q.push({s, 0, 0}); // 入队列

    while (q.size()) {
        Node x = q.top();
        q.pop();

        int u = x.u, k = x.k; // u:节点号，k:是最短路还是次短路，d:路径长度(这个主要用于堆中排序，不用于实战，实战中可以使用dis[u][k])

        if (st[u][k]) continue; // ① 和dijkstra标准版本一样的，只不过多了一个维度
        st[u][k] = true;

        for (int i = h[u]; ~i; i = ne[i]) {
            int j = e[i];
            int dj = dis[u][k] + w[i]; // 原长度+到节点j的边长

            if (dj == dis[j][0]) // 与到j的最短长度相等，则更新路径数量
                cnt[j][0] += cnt[u][k];
            else if (dj < dis[j][0]) { // 找到更小的路线，需要更新
                dis[j][1] = dis[j][0]; // 次短距离被最短距离覆盖
                cnt[j][1] = cnt[j][0]; // 次短个数被最短个数覆盖

                dis[j][0] = dj;        // 更新最短距离
                cnt[j][0] = cnt[u][k]; // 更新最短个数

                q.push({j, dis[j][1], 1}); // ②
                q.push({j, dis[j][0], 0});
            } else if (dj == dis[j][1])    // 如果等于次短
                cnt[j][1] += cnt[u][k];    // 更新次短的方案数，累加
            else if (dj < dis[j][1]) {     // 如果大于最短，小于次短，两者中间
                dis[j][1] = dj;            // 更新次短距离
                cnt[j][1] = cnt[u][k];     // 更新次短方案数
                q.push({j, dis[j][1], 1}); // 次短入队列
            }
        }
    }
}
int main() {
    int T;
    scanf("%d", &T);
    while (T--) {
        memset(h, -1, sizeof h);
        scanf("%d %d", &n, &m);
        while (m--) {
            int a, b, c;
            scanf("%d %d %d", &a, &b, &c);
            add(a, b, c);
        }
        // 起点和终点
        scanf("%d %d", &s, &f);
        // 计算最短路
        dijkrsta();
        // 输出
        printf("%d\n", cnt[f][0] + (dis[f][1] == dis[f][0] + 1 ? cnt[f][1] : 0));
    }
    return 0;
}

```