最短路计数，次短路计数

https://www.acwing.com/problem/content/385/

acwing 1134.最短路计数

①$bfs$ 每个点只出队一次，且入队一次

②$dijkstra$ 每个点第一次出队的序列一定满足拓扑序

③$bellman-ford(spfa)$ 出队的时候都不一定是满足最小，每个点可能出队多次，有可能更新前面已经出队的点，不具备拓扑序

但是要用$spfa$求最短路径数，也是可以的。比如当边权有负数时，就只能用$spfa$，先用$spfa$跑一遍，将每个点的最短路径跑出，然后建立最短路径树，在树上进行$dp$（拓扑排序）。

当$dis[j] > dis[t] + 1$时，转移，并将$cnt[t]$的值赋给$cnt[j]$， 当$dis[j] = dis[t] + 1$时，累加，将$cnt[j] = (cnt[j] + cnt[t])$。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>

using namespace std;

const int mod = 100003;

const int N = 1e5 + 10, M = 4e5 + 10;
int e[M], ne[M], h[N], idx;
int dis[N];
bool st[N];
int cnt[N];
int n, m;

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}

void bfs()
{
    memset(dis, 0x3f, sizeof dis);
    dis[1] = 0;
    cnt[1] = 1;
    queue<int> q;
    q.push(1);
    
    while(q.size())
    {
        int t = q.front();
        q.pop();
        
        for(int i = h[t] ; ~ i ; i = ne[i])
        {
            int j = e[i];
            if(dis[j] > dis[t] + 1)
            {
                dis[j] = dis[t] + 1;
                cnt[j] = cnt[t];
                q.push(j);
            }
            else if(dis[j] == dis[t] + 1)
            {
                cnt[j] = (cnt[j] + cnt[t]) % mod;
            }
        }
    }
}

int main(){
    cin >> n >> m;
    
    memset(h, -1, sizeof h);
    while(m --)
    {
        int a, b;
        cin >> a >> b;
        add(a, b), add(b, a);
    }
    
    bfs();
    
    for(int i = 1 ; i <= n ; i ++)cout << cnt[i] << endl;
    return 0;
}

 

 

https://www.acwing.com/activity/content/problem/content/1506/1/

acwing 383.观光

 

在求最短路数的基础上进行求次短路数。和在树中求最大直径和次大直径的方法一样。在最短路数的基础上：

①如果当前小于最短路，先更新次短路数，加入堆，再更新最短路数，加入堆；

②再如果当前等于最短路，累加最短路数；

③再如果当前小于次短路，更新次短路数，加入堆；

④最后如果当前等于次短路数，累加次短路数。

次短路数和最短路数一样，都是满足拓扑序的，所以使用$dijkstra$算法求解。

#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>
#include <vector>

using namespace std;

const int N = 1010, M = 20010;

struct Node{
    int ver, type, dis;
    bool operator > (const Node &W)const{
        return dis > W.dis;
    }
};

int e[M], ne[M], w[M], h[N], idx;
int dis[N][2], cnt[N][2];
bool st[N][2];
int n, m;
int S, E;

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(cnt, 0, sizeof cnt);//多组测试数据必须全部初始化
    priority_queue<Node, vector<Node>, greater<Node>> heap;
    dis[S][0] = 0;
    cnt[S][0] = 1;//最开始没有次短路
    heap.push({S, 0, 0});
    
    while(heap.size())
    {
        Node t = heap.top();
        heap.pop();
        
        int ver = t.ver, type = t.type, distance = t.dis, count = cnt[ver][type];
        if(st[ver][type])continue;
        st[ver][type] = true;
        
        for(int i = h[ver] ; ~ i ; i = ne[i])
        {
            int j = e[i];
            if(dis[j][0] > distance + w[i])//分别对应一二三四种情况。
            {
                dis[j][1] = dis[j][0], cnt[j][1] = cnt[j][0];
                heap.push({j, 1, dis[j][1]});
                dis[j][0] = distance + w[i], cnt[j][0] = count;
                heap.push({j, 0, dis[j][0]});
            }
            else if(dis[j][0] == distance + w[i])cnt[j][0] += count;
            else if(dis[j][1] > distance + w[i])
            {
                dis[j][1] = distance + w[i], cnt[j][1] = count;
                heap.push({j, 1, dis[j][1]});
            }
            else if(dis[j][1] == distance + w[i])cnt[j][1] += count;
        }
    }
    int res = cnt[E][0];
    if(dis[E][0] + 1 == dis[E][1])res += cnt[E][1];
    return res;
}

int main(){
    int T;
    cin >> T;
    while(T --)
    {
        cin >> n >> m;
        memset(h, -1, sizeof h);
        idx = 0;//注意多组数据，idx和表头都要初始化
        while(m --)
        {
            int a, b, c;
            cin >> a >> b >> c;
            add(a, b, c);
        }
        
        cin >> S >> E;
        
        cout << dijkstra() << endl;
    }
    return 0;
}