几个基础的最短路和最小生成树问题

前言

复习一下最短路和最小生成树，都是一些最基础的应用，稍微整理一下。

最短路

最短路计数

其实就是询问最短路有多少条。

因为最短路算法（ Dijkstra , sfpa 等等 ) 本身都算是 BFS+贪心的过程，那么我们只需要在松弛一个节点的时候更新它邻接节点的最短路径数目就可以。

目前在节点 u ， 它有一个邻接节点 v ，从 s --> u 的最短路有 ans[u] 条。

若$dis[v]>dis[u]+e[u][v]$,我们更新$dis[v]$, 并将$ans[v]$重置为$ans[u]$ 。

若$dis[v]=dis[u]+e[u][v]$,我们将 $ans[v]$ 加上 $ans[u]$ 。

例题

代码

#include<bits/stdc++.h>
using namespace std;
const int N = 2e6+100;
const int mod = 100003;
struct E{
    int to;
    int nxt;
    int w;
}e[N<<1];
int head[N],tot;
int n,m;
void add_edge(int u,int v,int w){
    e[++tot].to = v;
    e[tot].w = w;
    e[tot].nxt = head[u];
    head[u] = tot;
}
bool vis[N];
int dis[N],ans[N];
void dijkstra(int s){
    memset(dis,0x3f3f3f3f,sizeof dis);
    priority_queue<pair<int,int>> q;
    q.push(make_pair(0,s));
    dis[s] = 0,ans[s] = 1;
    while(!q.empty()){
        pair<int,int> now = q.top();
        int u = now.second;
        q.pop();
        if(vis[u]) continue;
        vis[u] = true;
        for(int i=head[u];i;i=e[i].nxt){
            int v = e[i].to;
            if(vis[v]) continue;
            if(dis[v]>dis[u]+e[i].w){
                dis[v] = dis[u]+e[i].w;
                ans[v] = ans[u];
                q.push(make_pair(-dis[v],v));
            }
            else if(dis[v]==dis[u]+e[i].w){
                ans[v] = (ans[v]+ans[u])%mod;
            }
        }
    }
}
int main(){
    cin>>n>>m;
    for(int i=1;i<=m;i++){
        int x,y;
        cin>>x>>y;
        add_edge(x,y,1);
        add_edge(y,x,1);
    }
    dijkstra(1);
    for(int i=1;i<=n;i++){
        cout<<ans[i]<<endl;
    }
    return 0;
}

多源最短路问题

有两个起点$a,b$ ，一个终点 $s$ , 找到一个权值最小的子图，使得 $a $能到 $s$ ，$b$ 能到$s$.

简单来说，求 $a,b$ 到 $s$ 的最短路之和，允许路径重叠, 如下图------红色的路径即所求。
(画得好丑呜呜呜~）

其实这个问题并不难。

我们发现所有的情况下的最短路都可以归结为一种走法，那就是 a , b 先在某中间点 M 汇合（如上图5号点），再从M一起走向S。

因为其他的所有特殊情况其实就是 $M=a,M=b,M=s$ 的情况。

那么问题就变成了对图中的任意一点 $M_i$ ,

ans = min { $dis[a->M_i]+dis[b->M_i]+dis[M_i->s]$ }

对于 $dis[a->M_i],dis[b->M_i]$ ， 我们分别以a,b点为起点跑一遍最短路即可 ， 得到的 $di{s}_a[],di{s}_b[]$ 即所求。

对于 $dis[M_i->s]$ , 我们构建原图的反图 ，显然，原图中的 $dis[M_i->s]$ 就是反图中的 $dis[s->M_i]$，因此以 s 为起点跑一遍最短路，得到的$di{s}_s[]$ 即所求。

ans = min { $di{s}_a[]+di{s}_b[]+di{s}_s[]$ }

因为要建反图，写起来代码可能比较长，但反正都是 ctrl c+v 一遍就好。

例题

这个模板挺多的，比如最近的一道 leetcode :

(感觉我写的好乱啊，呜呜呜~~)

https://leetcode-cn.com/problems/minimum-weighted-subgraph-with-the-required-paths/

代码

class Solution {
public:
    long long dis[2][100100];
    long long to[100100];
    long long from[100100];
    const long long inf = 1e15;
    map<int,int> mp[100100];
    struct E{
        int to;
        int nxt;
        int w;
    }e[100100<<1],e2[100100<<1];
    int head[100100],tot;
    int head2[100100],tot2;
    int N;
    bool vis[100100];
    void add_edge(int u,int v,int w){
        e[++tot].to = v;
        e[tot].w = w;
        e[tot].nxt = head[u];
        head[u] = tot;
    }
    void add_edge2(int u,int v,int w){
        e2[++tot2].to = v;
        e2[tot2].w = w;
        e2[tot2].nxt = head2[u];
        head2[u] = tot2;
    }
    void dij(int s,int opt){
        memset(vis, false,sizeof vis);
        priority_queue<pair<long long,int>> q;
        q.push(make_pair(0,s));
        dis[opt][s] = 0;
        while(!q.empty()){
            pair<long long,int> now = q.top();
            q.pop();
            int u = now.second;
            if(vis[u]) continue;
            vis[u] = true;
            for(int i=head[u];i;i=e[i].nxt){
                int v = e[i].to;
                int w = e[i].w;
                if(!vis[v]&&dis[opt][v]>dis[opt][u]+w){
                    dis[opt][v] = dis[opt][u]+w;
                    q.push(make_pair(-dis[opt][v],v));
                }
            }
        }
    }
    void dij2(int s){
        memset(vis, false,sizeof vis);
        priority_queue<pair<long long ,int>> q;
        q.push(make_pair(0,s));
        to[s] = 0;
        while(!q.empty()){
            pair<int,long long> now = q.top();
            q.pop();
            int u = now.second;
            if(vis[u]) continue;
            vis[u] = true;
            for(int i=head2[u];i;i=e2[i].nxt){
                int v = e2[i].to;
                int w = e2[i].w;
                if(!vis[v]&&to[v]>to[u]+w){
                    to[v] = to[u]+w;
                    q.push(make_pair(-to[v],v));
                }
            }
        }
    }
    long long minimumWeight(int n, vector<vector<int>>& edges, int src1, int src2, int dest) {
        N = n;
        for(int i=0;i<n;i++){
            dis[0][i] = dis[1][i] = inf;
            to[i] = inf;
        }
        for(int i=0;i<edges.size();i++){
            vector<int> now = edges[i];
            int u = now[0],v = now[1],w = now[2];
            if(!mp[u][v]) mp[u][v] = w;
            else mp[u][v] = min(mp[u][v],w);
        }
        for(int i=0;i<edges.size();i++){
            vector<int> now = edges[i];
            int u = now[0],v = now[1],w = now[2];
            if(mp[u][v]!=w) continue;
            add_edge(u,v,w);
            add_edge2(v,u,w);
        }
        int s1 = src1,s2 = src2,ee = dest;
        dij(s1,0),dij(s2,1),dij2(ee);
        for(int i=0;i<n;i++)
            from[i] = dis[0][i]+dis[1][i];
        long long ans = inf;
        for(int i=0;i<n;i++)
            ans = min(ans,to[i]+from[i]);
        return (ans>=inf)?-1:ans;
    }
}ss;

待更

…