最短路计数（bfs）

最短路计数

题目描述

给出一个 $N$ 个顶点 $M$ 条边的无向无权图，顶点编号为 $1\sim N$。问从顶点 $1$ 开始，到其他每个点的最短路有几条。

输入格式

第一行包含 $2$ 个正整数 $N,M$，为图的顶点数与边数。

接下来 $M$ 行，每行 $2$ 个正整数 $x,y$，表示有一条由顶点 $x$ 连向顶点 $y$ 的边，请注意可能有自环与重边。

输出格式

共 $N$ 行，每行一个非负整数，第 $i$ 行输出从顶点 $1$ 到顶点 $i$ 有多少条不同的最短路，由于答案有可能会很大，你只需要输出 $ ans \bmod 100003$ 后的结果即可。如果无法到达顶点 $i$ 则输出 $0$。

样例 #1

样例输入 #1

5 7
1 2
1 3
2 4
3 4
2 3
4 5
4 5

样例输出 #1

1
1
1
2
4

提示

$1$ 到 $5$ 的最短路有 $4$ 条，分别为 $2$ 条 $1\to 2\to 4\to 5$ 和 $2$ 条 $1\to 3\to 4\to 5$（由于 $4\to 5$ 的边有 $2$ 条）。

对于 $20\%$ 的数据，$1\le N\le 100$；
对于 $60\%$ 的数据，$1\le N\le 10^3$；
对于 $100\%$ 的数据，$1\le N\le 10^6$，$1\le M\le 2\times 10^6$。

题解：

当处理不带权的图的时候，我们求最短路便优先考虑bfs即可。

我们考虑一种递推关系：

• 对于任意一个结点v，到达v的最短路径数=它所有父节点的最短路径数之和。

明确了递推关系之后，那么就差不多可以解题了，但仍有几个注意点：

• 由于给出的是无向图，所以要注意不能回溯到父亲结点，不然就会出现死循环。不过，如果出现这样的回溯，势必步数会大于最短路径长度，所以加一个判断就好。

• 当一个结点有多条最短路径可达的时候，可能是重边也可能不是，无论是不是，只能入队一次。所以要使用vis数组判断一个结点是否已经入队。

  if (!vis[v]) {
       q.push({ v,t_dis });
       vis[v] = 1;
  }
  

以下是完整代码：

#include <iostream>
#include <queue>
#include <algorithm>
using namespace std;
const int mod = 100003, inf = 1e8 - 3;
int n, m;
int cnt = 0, head[1000001] = { 0 };
int dis[1000001], ans[1000001] = { 0 }; bool vis[1000001] = { 0 };
struct Edge {
    int to, next;
}e[2000001];

void add_edge(int u, int v) {
    cnt++;
    e[cnt].to = v;
    e[cnt].next = head[u];
    head[u] = cnt;
}

inline void read(int& x) {
    int ans = 0; char ch = getchar();
    while (ch < '0' || ch>'9') {
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        ans = (ans << 1) + (ans << 3) + (ch ^ 48);
        ch = getchar();
    }
    x = ans;
}

inline void print(int x) {
    if (x > 9) {
        print(x / 10);
    }
    putchar(x % 10 + '0');
}

void bfs() {
    fill(dis + 1, dis + n + 1, inf);
    //first表示结点编号，second表示最短路径的长度
    queue<pair<int, int>> q;
    q.push({ 1, 0 });
    dis[1] = 0; ans[1] = 1; vis[1] = 1;
    while (q.size()) {
        auto t = q.front(); q.pop();
        int t_dis = t.second + 1;
        for (int i = head[t.first]; i; i = e[i].next) {
            int v = e[i].to;
            if (t_dis <= dis[v]) {
                dis[v] = t_dis;
                ans[v] = (ans[v] + ans[t.first]) % mod;
                if (!vis[v]) {
                    q.push({ v,t_dis });
                    vis[v] = 1;
                }
            }
        }
    }
}

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= m; i++) {
        int u, v;
        read(u), read(v);
        add_edge(u, v);
        add_edge(v, u);
    }
    bfs();
    for (int i = 1; i <= n; i++) {
        print(ans[i]); putchar('\n');
    }
    return 0;
}