其他分享
首页 > 其他分享> > 模板 --单源最短路

模板 --单源最短路

作者:互联网

模板 --单源最短路

求最短路一般有两种方法,dij,SPFA;

大多数情况下最常用并且最稳妥的就是dij,SPFA一般用于判断负权值和负环,并且如果边较多,SPFA容易被卡死。所以一般情况下都是使用dij。

首先先介绍dij

dij算法的主要思想是先寻找一个点A1,将这个点并入一个集合,然后找出与这个点相连的点中路径最小的点A2,然后将A2并入集合,将与A2相连点A3的路径加上A1到A2点的路径与A1到A3的路径比较,如果前者小于后者,就将A1到A3路径更新。

以此类推,直到将所有点加入集合中。我们用一个数组储存点A到所有点的最短路径。

图的存储也有多种方式,例如二维数组储存(邻接矩阵),C++中STL里的vector储存,还有链式前向星(邻接表)。其中用二维数组储存只能使用与数据范围较小的题,如果数据范围超过1e5,基本都是使用vector和链式前向星储存。

下面先放一个二维数组储存的代码模板;

void Dij(int s) // s为起点
{
    memset(vis, 0, sizeof(vis));
    dis[s]=0;
    for(int i = 1; i <= n; i++)dis[i] = INF;//INF为一个很大的数
    int v,mn;
    for(int i = 1; i <= n; i++)
    {
        mn = INF;
        for(int j = 1; j <= n; j++)//找最小值的点
        {
            if(!vis[j] && dis[j] < mn)
            {
                mn = dis[j];
                v = j;
            }
        }
        vis[v] = 1;
        for(int j = 1; j <= n; j++)
        {
            if(!vis[j] && (mn + mp[v][j]) < dis[j])dis[j] = mn + mp[v][j];
        }
    }
}

一般情况下不推荐使用邻接矩阵存图,很容易TLE;

下面是使用C++STL中的vector存图;

#include<iostream>
#include<cstring>
#include<cstdio>
#include<string>
#include<queue>
#include<stack>
#include<algorithm>
#include<vector>
#include<map>
#include<cmath>
#define long long ll;
using namespace std;
const int MAXN= 0x3f3f3f3f;
const int INF =2147483647;
struct node{
    int v;
    int w;
};//创建一个结构体,到达点和距离。
node make_out(int x,int y)
{
    node t;
    t.v = x;
    t.w = y;
    return t;
//将到达点和距离存入vector。
}
vector<node> q[500001];
int n, m, s;
int d[500001];
int vis[500001];
void dij(int x)
{
        memset(vis, 0, sizeof(vis));
         for (int i = 1; i <= n;i++)
       { d[i] = INF;}//初始化赋值为最大值
    for (int i=0; i < q[x].size();i++)
    {
        int h = q[x][i].v;
        d[h] = q[x][i].w;
    }//更新与X到与X相邻点的距离
    d[x] = 0;//到本身的距离为0
    int pos;
    for (int i = 1; i < n; i++)//寻找路程最小的点
    {
        int mm = INF;
        for (int j = 1; j <= n; j++)
        {
            if (!vis[j] && mm > d[j])
            {
                mm = d[j];
                pos = j;
            }
        }
        vis[pos] = 1;
        for (int k = 0; k < q[pos].size(); k++)//松弛操作
        {
            int h = q[pos][k].v;
            if (d[h]>q[pos][k].w +d[pos])
            {
                d[h] = q[pos][k].w +d[pos];
            }
        }
    }
}
int main()
{
    cin >> n >> m >> s;
        for (int i = 1; i <= m; i++)
        {
            int x, y, z;
            cin >> x >> y >> z;
            q[x].push_back(make_out(y, z));
        }
        dij(s);
        for (int i = 1; i <= n;i++)
        {
    
            cout << d[i]<<' ';
        }
        return 0;
}





然后就是使用链式前向星,跟Vector一样都是邻接表储存方式。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<string>
#include<queue>
#include<stack>
#include<algorithm>
#include<vector>
#include<map>
#include<cmath>
using namespace std;
const int INF= 0x3f3f3f3f;
const int MAXN = pow(2, 31) - 1;
int head[500001];//head是储存最新起始点的位置
int ans = 0;
queue<int> q;
struct edge
{
    int u, v, w, next;//next是储存上一条边的位置
}e[500001];
int n, m;
void add(int u,int v,int w)//链式前向星存图
{
    e[++ans].next = head[u];
    e[ans].v = v;
    e[ans].w = w;
    head[u] = ans;
}
int d[500001];
int vis[500001];
void DIJ(int x)
{
    memset(vis, 0, sizeof(vis));//跟vector类似
    for (int i = 1; i <= n;i++)
    {
        d[i] = MAXN;
    }
        d[x] = 0;

        int pos = x;
        while (!vis[pos])//这里的意思是是否访问所有点的
            {for (int i = head[pos]; i != 0;i=e[i].next)
            {
                int h = e[i].v;//松弛操作
                if(d[h]>d[pos]+e[i].w)
                {
                    d[h] = d[pos] + e[i].w;
                }
            }
            vis[pos] = 1;
            int mn = MAXN;
            for (int j = 1; j <= n; j++)//寻找最大值的点
            {
                if (!vis[j] && mn > d[j])
                {
                    mn = d[j];
                    pos = j;
                }

                }
                
            }
}
int main()
{
    int s;
    cin >> n >> m>>s;
    for (int i = 1; i <= m;i++)
    {
        int x, y, z;
        cin >> x >> y >> z;
        add(x, y, z);
    }
   DIJ(s);
    for (int i = 1; i <= n;i++)
    {
        cout << d[i] << " ";
    }
        return 0;
}



以上三种方式都是使用普通的dij,但是有时候会遇到一些数据很大的,dij还是可以优化的,最常用的就是dij的堆优化。

所谓的堆优化就是使用C++STL中的优先队列来维护dij,dij中有一步是寻找距离最小的点。使用堆优化就可以减少时间复杂度。

下面放堆优化模板

#include<iostream>
#include<cstring>
#include<cstdio>
#include<string>
#include<queue>
#include<stack>
#include<algorithm>
#include<vector>
#include<map>
using namespace std;
const int MAXN= 0x3f3f3f3f;
struct node{
    int u;
    int s2;
    bool operator <(const node& r)const//重载优先队列,最小堆
    {
        return r.s2 < s2;
    }
};
struct MS
{
    int u, v, w, next;
}e[200001];
int head[200001];
int ans = 0;
void add(int u,int v,int w)//链式前向星
{
    e[++ans].next = head[u];
    e[ans].v = v;
    e[ans].w = w;
    head[u] = ans;
}
priority_queue<node> q;//优先队列
int d[200001];
int n, m,s;
void dij()
{
    for (int i = 1; i <= n;i++)
       { d[i] = 2147483647;}
        d[s] = 0;
    q.push((node){s, 0});//将距离和点放入优先队列中
while(!q.empty())
{
    node t = q.top();//取堆顶元素,距离一定是最小的
    q.pop();
    int u = t.u;
    int s1 = t.s2;
     if(s1!=d[u])//这步是堆优化的基本操作,防止没更新的进入循环,减少时间复杂度
            continue;
    for (int i = head[u]; i != 0;i=e[i].next)
    {int v1 = e[i].v;
        if (d[v1]>d[u]+e[i].w)//链式前向星基本遍历操作,松弛操作
        {
            d[v1] = d[u] + e[i].w;
            q.push((node){v1, d[v1]});//入队
        }
    }
}
}
int main()
{
    cin >> n >> m >> s;
    for (int i = 1; i <= m;i++)
    {
        int x, y, z;
        cin >> x >> y >> z;
        add(x, y, z);
    }
    dij();
    for (int i = 1; i <= n;i++)
       { cout << d[i]<<' ';}
        return 0;
}





dij算法差不多结束了,接下来就是SPFA.

SPFA也是一种求单源最短路的算法。

其实它的思路跟dij差不多,但是不同的是dij的入集合的点是不会再变动,而SPFA中集合中的点一直有变动,并且SPFA是使用队列来维护,已经入集合的点也是有可能出来。

下面放代码

#include<iostream>
#include<cstring>
#include<cstdio>
#include<string>
#include<queue>
#include<stack>
#include<algorithm>
#include<vector>
#include<map>
#include<cmath>
using namespace std;
const int INF= 0x3f3f3f3f;
const int MAXN = pow(2, 31) - 1;
struct node{
    int u, v, w, next;
}e[500001];
int head[500001];
int ans = 0;
void add(int u,int v,int w)//链式前向星
{
    e[++ans].next = head[u];
    e[ans].v = v;
    e[ans].w = w;
    head[u] = ans;
}
int n, m, s;
queue<int> q;
int vis[500001];
int d[500001];
void SPFA(int x)
{
    for (int i = 1; i <= n;i++)
        d[i] = MAXN;
    d[x] = 0;
    q.push(x);
    vis[x] = 1;//入队标记为1
    while(!q.empty())
    {
        int h = q.front();
        q.pop();
        vis[h] = 0;//出队标记为0
        for (int i = head[h]; i!=0;i=e[i].next)
        {
            int t = e[i].v;
           if(d[t]>d[h]+e[i].w)//松弛操作
               { d[t] = d[h] + e[i].w;
                if(!vis[t])//如果队里不存在相同的点,则入队。
                {
                    q.push(t);
                }}
        }
    }
}
int main()
{
    cin >> n >> m >> s;
    memset(vis, 0, sizeof(vis));
    memset(d, 0, sizeof(d));
    for (int i = 1; i <= m;i++)
    {
        int x, y, z;
        cin >> x >> y >> z;
        add(x, y, z);
    }
    SPFA(s);
    for (int i = 1; i <= n;i++)
    {
        cout << d[i] << ' ';
    }
        return 0;
}

标签:dij,vis,--,单源,pos,int,500001,include,模板
来源: https://www.cnblogs.com/a821403286/p/13693036.html