洛谷 P1144 最短路计数（bfs模板题，稍加修改）

57 阅读 0 评论 38 点赞

我是靠谱客的博主优雅小土豆，最近开发中收集的这篇文章主要介绍洛谷 P1144 最短路计数（bfs模板题，稍加修改），觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

题目链接：

最短路计数 - 洛谷https://www.luogu.com.cn/problem/P1144

思路：

基本上是一个模板题，只不过要输出的不是最短路距离，而是最短路数量，所以需要一个cnt数组，如果当前是更短的最短路，cnt重新计数，等于到上个点的cnt值，如果当前是和之前长度相等的最短路，cnt和之前累加。注意答案取模。

当时做这道题没有什么感觉，套完模板稀里糊涂的就ac了，写完之后总结了一下感觉收获不少。最短路问题中，dist数组和vis数组是必不可少的，dist数组用来记录最短路长度，在本题中作用体现为：用来判断当前路是不是最短路。而vis数组则用来避免重复遍历，避免边上两点相互push对方进队列，导致无限循环。cnt是模板之外的内容，要加入是因为本题要求计算最短路数量。

------------------------------------------------------------------------------------------------------------------------------

第二天更新：今天突然发现我的代码中vis数组是可以删掉的，因为我做了一个 if (dist[v] > dist[u] + 1)的判断，如果 v 是之前遍历过的点，此时的dist[v]必定比 dist[u] + 1要小，所以这个vis数组没有存在的必要！（删掉vis数组之后的代码放在最后了）

代码：

我的代码：

#include <iostream>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;
const int maxn = 1e6+5, maxm = 2e6+5;
const int mod = 100003;
vector<int> g[maxn]; //edge
int dist[maxn]; //cost 1 to i
bool vis[maxn]; //wheather i is vised
int cnt[maxn]; //count of min cost 1 to i
int n, m; //point count, edge count

void bfs(){
    memset(dist, 0x3f3f3f3f,sizeof(dist));
    memset(vis, false, sizeof(vis));
    queue<int> q;
    dist[1] = 0;
    cnt[1] = 1;
    q.push(1);
    while(q.size()){
        int u = q.front(); q.pop();
        if(vis[u]) continue; //这句实际上是可以删掉的，因为一个点只会被push一次
        vis[u] = true;
        for(int v : g[u]){
            if(!vis[v]){
                if(dist[v] > dist[u] + 1){
                    //当前是新的最短路，cnt重新计数
                    dist[v] = dist[u] + 1;
                    cnt[v]=cnt[u];
                    cnt[v] %= mod;
                    q.push(v);
                }
                else if(dist[v] == dist[u] + 1){
                    //当前是长度和之前一样的最短路，cnt累加
                    cnt[v] += cnt[u];
                    cnt[v] %= mod;
                }
            }
        }
    }
}

int main(){
    cin >> n >> m;
    for(int i=0; i<m; i++){
        int a, b;
        cin >> a >> b;
        g[a].push_back(b);
        g[b].push_back(a);
    }
    bfs();
    for(int i=1; i<=n; i++){
        cout << cnt[i] << endl;
    }
    return 0;
}

我队友的代码，它的layer数组（相当于我的dist数组）同时做到了vis数组的效果，非常巧妙。

#include <iostream>
#include <queue>
#include <vector>
using namespace std;

vector<int> v[1000100];
int d[1000100], layer[1000100]; //最短路数量，最短路长度
void bfs()
{
    queue<int> q;
    q.push(1);
    while (!q.empty())
    {
        int p = q.front();
        q.pop();
        d[1] = 1;
        layer[1] = 1;
        for (int i = 0; i < v[p].size(); i++){
            //v[p][i]表示p结点的第i个连接点
            if (!layer[v[p][i]]) //相当于有一个vis判断，layer值为0说明没有遍历过
            {
                q.push(v[p][i]); //没有遍历过，要加入队列
                layer[v[p][i]] = layer[p] + 1; //第一次遍历这个点，更新最短距离
            }
            if (layer[v[p][i]] > layer[p])
                //两个layer值差值要么是1，要么是0，这里是差值为1的情况
                //这就说明当前p到v[p][i]也是最短路之一，要加上这个结果
                d[v[p][i]] = (d[v[p][i]] + d[p]) % 100003;
        }
    }
}

int main()
{
    int n, m, U, V;
    cin >> n >> m;
    for (int i = 1; i <= m; i++)
    {
        cin >> U >> V;
        if (U != V) //忽视自环（其实也可以没有）
        {
            v[V].push_back(U);
            v[U].push_back(V);
        }
    }
    bfs();
    for (int i = 1; i <= n; i++)
        cout << d[i] << "n";
}

我的代码中vis数组删掉之后一样可以ac：

#include <iostream>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;
const int maxn = 1e6+5, maxm = 2e6+5;
const int mod = 100003;
vector<int> g[maxn]; //edge
int dist[maxn]; //cost 1 to i
int cnt[maxn]; //count of min cost 1 to i
int n, m; //point count, edge count

void bfs(){
    memset(dist, 0x3f3f3f3f,sizeof(dist));
    queue<int> q;
    dist[1] = 0;
    cnt[1] = 1;
    q.push(1);
    while(q.size()){
        int u = q.front(); q.pop();
        for(int v : g[u]){
            if(dist[v] > dist[u] + 1){
                //当前是新的最短路，cnt重新计数
                dist[v] = dist[u] + 1;
                cnt[v]=cnt[u];
                cnt[v] %= mod;
                q.push(v);
            }
            else if(dist[v] == dist[u] + 1){
                //当前是长度和之前一样的最短路，cnt累加
                cnt[v] += cnt[u];
                cnt[v] %= mod;
            }
        }
    }
}

int main(){
    cin >> n >> m;
    for(int i=0; i<m; i++){
        int a, b;
        cin >> a >> b;
        g[a].push_back(b);
        g[b].push_back(a);
    }
    bfs();
    for(int i=1; i<=n; i++){
        cout << cnt[i] << endl;
    }
    return 0;
}