最短路基础实现方法模板合集

$\mathrm{关}\mathrm{于}\mathrm{最}\mathrm{短}\mathrm{路}$

$\mathrm{首}\mathrm{先}\mathrm{是}\mathrm{最}\mathrm{短}\mathrm{路}\mathrm{的}\mathrm{算}\mathrm{法}\mathrm{选}\mathrm{择}\mathrm{思}\mathrm{路}\mathrm{捏},\mathrm{直}\mathrm{接}\mathrm{来}\mathrm{个}Y\mathrm{总}\mathrm{的}\mathrm{图}$

++$\mathrm{单}\mathrm{源}\mathrm{汇}\mathrm{问}\mathrm{题}$++

$\mathrm{朴}\mathrm{素}\mathrm{版}Dijkstra$

实现思路

//朴素版Dijkstra   o(n^2)  -- 处理稠密图  -- 稠密图用邻接矩阵存储
//1. 初始化 邻接矩阵  -- 时间复杂度是o(n ^ 2)
//2. 输入数据
//3. 开始dijkstra
//4. 初始化距离数组,起点距离是0
//5. 循环n - 1次，每次找到最近的点t
//6. 找到最近的点t后，用点t来更新每一个的值

具体代码

#include<iostream>
#include<cstring>
using namespace std;

const int N = 510;
int g[N][N];
int d[N];     //存起点到每个点的最短距离
bool st[N];   //这个点是否已经被确定最短距离
int n,m;
long long res = 0;

int dijkstra()
{
    //初始化距离
    memset(d, 0x3f, sizeof d);
    d[1] = 0;
    for(int i=0; i < n-1; i++)
    {
        //找到没有确定最短路的点的距离最小的那一个
        int t = -1;
        for(int j=1; j <= n; j++)
            if(!st[j] && (t== -1 || d[t] > d[j]))
                t = j;

        st[t] = true;

        //用t更新其他点的距离,就是用1 到 t 到 j的距离,更新一下 1 到 j
        for(int j=1; j <= n; j++)
            d[j] = min(d[j], d[t] + g[t][j]);
    }

    if(d[n] == 0x3f3f3f3f) return -1;

    return d[n];
}
int main()
{
    scanf("%d%d", &n, &m);
    //初始化
    memset(g, 0x3f, sizeof g);
    //输入数据        
    while(m -- )
    {
        int a,b,c;
        scanf("%d%d%d", &a, &b, &c);
        g[a][b] = min(g[a][b], c);
    }

    int t = dijkstra();

    printf("%d", t);
    return 0;
}

$\mathrm{堆}\mathrm{优}\mathrm{化}\mathrm{版}Dijkstra$

实现思路

// 堆优化， 这个dijkstra 的时间复杂度是 o(m * log n)
//这个是个稀疏图， 所以采用邻接表的方式存储
//1. 也是初始化
//2. 输入数据
//3. 开始dj
//4. 初始化距离数组
//5. 用优先队列来维护整个图priority_queue<PII, vector<PII>, greater<PII>> ,里面是pair型
//6. ver来代表这个节点的位置
//7. 开始遍历ver节点可以到的每一个节点
//8. 用j来存储这个节点图中的位置
//9. 如果d[j] > d[ver] + w[i] 就更新一下d[j]
//10. 最后再让{d[j], j}入列

具体代码

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

typedef pair<int ,int> PII;
const int N = 100010, M = N * 2;
int h[N], ne[M], e[M], idx, w[M];
int d[N], n, m;
bool st[N];


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

int dijkstra()
{
    memset(d, 0x3f, sizeof d);
    d[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> q;
    q.push({0, 1});
    while(q.size())
    {
        auto t = q.top();
        q.pop();
        int ver = t.second;
        if(st[ver]) continue;
        st[ver] = true;
        for(int i=h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if(d[j] > d[ver] + w[i]){
                d[j] = d[ver] + w[i];
                q.push({d[j], j});
            }
        }
    }
    if(d[n] == 0x3f3f3f3f) return -1;
    else return d[n];
}

int main()
{
    memset(h, -1, sizeof h);
    scanf("%d%d", &n , &m);
    while( m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }
    printf("%d", dijkstra());
    return 0;
}

++$\mathrm{单}\mathrm{源}\mathrm{汇}\mathrm{有}\mathrm{负}\mathrm{权}\mathrm{边}\mathrm{问}\mathrm{题}$++

$Bellma{n}_{f}ord\mathrm{算}\mathrm{法}$

实现思路

//bellman_ford最短路，处理的是有负数边，而且限定次数的, 时间复杂度是o(nm)
//1. 这个里面用什么都可以，邻接表、邻接矩阵、都行，这里用的是结构体；
//2. 定义结构体,距离数组、备份数组, 输入数据
//3. 调用bellman_ford()
//4. 初始化距离数组
//5. 遍历k次,其中每次遍历m次，就是因为是m条边
//6. 每次都要备份一下d，因为怕串联
//7. 每次遍历中都需要取出来每个点
//8. 然后不断更新d[b] = min(d[b], backup[a] + w)

具体代码

#include<iostream>
#include<cstring>
using namespace std;
const int N = 510, M = 10010;
int n,m,k;
int d[N], backup[M];
struct Q{
  int a,b,w;  
}q[M];

int bellman_ford()
{
    memset(d, 0x3f, sizeof d);
    d[1] = 0;
    for(int i=1; i <= k; i++)
    {
        memcpy(backup, d, sizeof d);
        for(int j=1; j <= m ;j++)
        {
            int a = q[j].a, b = q[j].b, w = q[j].w;
            d[b] = min(d[b], backup[a] + w);
        }
    }

    if(d[n] > 0x3f3f3f3f / 2) return -0x3f3f3f3f;
    return d[n];
}

int main()
{
    scanf("%d%d%d", &n, &m, &k);
    for(int i=1; i <= m; i++)
        scanf("%d%d%d", &q[i].a, &q[i].b, &q[i].w);
    int t = bellman_ford();
    if(t == -0x3f3f3f3f) printf("impossible");
    else
        printf("%d", t);
    return 0;
}

$SPFA\mathrm{算}\mathrm{法}$

实现思路

SPFA也可以实现无负权边的
//这个是SPFA,是对于bellman_ford 的优化，用队列，时间复杂度是o(m)最坏是o(nm)
//这里的SPFA用邻接表存储的
//同样这个也是来算有负边的，但是一定不能有负环！！
//1. 定义邻接表、变量、队列、距离数组,bool st[]
//这个st呢是用来判断档当前这个点是否在队列中
//2. 初始化邻接表，输入数据
//3. 调用spfa算法 -- 跟dijkstra很像
//4. 队列维护， 基本的队列都得有
//5. 同样需要初始化距离数组，初始化队列
//6. 让st[t] 出列！
//7. 然后开始遍历从t开始的邻接表
//8. 然后让j来存储下一个点
//9. 后面就和dijkstra很像
//10. 如果j不在队列里面，就是j入列

具体代码

#include<iostream>
#include<cstring>
using namespace std;
const int N = 100010, M = N * 2;
int h[N], ne[M], e[M], w[M], idx;
int n,m;
int d[N], q[N];
bool st[N];

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

int spfa()
{
    memset(d, 0x3f, sizeof d);
    d[1] = 0;
    q[0] = 1;
    st[1] = true;
    int hh = 0, tt = 0;
    while(hh <= tt)
    {
        int t = q[hh++];
        st[t] = false;
        for(int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if(d[j] > d[t] + w[i]){
                d[j] = d[t] + w[i];
                if(!st[j])
                {
                    st[j] = true;
                    q[++tt] = j;
                }
            }
        }
    }
    if(d[n] > 0x3f3f3f3f / 2) return -0x3f3f3f3f;
    else return d[n];
}

int main()
{
    memset(h, -1,sizeof h);
    scanf("%d%d", &n, &m);
    while(m --)
    {
        int a,b,c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b ,c);
    }
    int t = spfa();
    if(t == -0x3f3f3f3f) printf("impossible");
    else printf("%d", t);
    return 0;
}

++$\mathrm{多}\mathrm{源}\mathrm{汇}\mathrm{问}\mathrm{题}$++

$Floyd\mathrm{算}\mathrm{法}$

实现思路

//用邻接矩阵存储的图
//解决的是多起点、多终点的最短路，时间复杂度是o(n^3)
//1. 定义邻接矩阵、初始化邻接矩阵
//2. 输入数据
//3. 调用floyd
//4. 核心操作d[i][j] = min(d[i][j], d[i][k] + d[k][j]);  //外前内后
//5. 调用完以后，d[a][b]就是存的a到b的最短路
//6. 如果a到b不能生成最短路那么，还是无限大

具体代码

#include<iostream>
using namespace std;
const int N = 210;
int d[N][N];
int n,m,q;

int floyd()
{
    for(int k=1; k <= n; k++)
        for(int i=1; i <= n; i++)
            for(int j=1; j <=n; j++)
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]); // 外前内后
}

int main()
{
    scanf("%d%d%d", &n, &m ,&q);
    for(int i=1; i <= n; i++)
        for(int j=1; j<=n; j++)
            if(i == j) d[i][j] = 0;
            else d[i][j] = 0x3f3f3f3f;

    while(m -- )
    {
        int a,b,c;
        scanf("%d%d%d", &a, &b, &c);
        d[a][b] = min(d[a][b], c);
    }
    floyd();
    while(q -- )
    {
        int a,b;
        scanf("%d%d", &a, &b);
        if(d[a][b] > 0x3f3f3f3f / 2) printf("impossible\n");
        else printf("%d\n", d[a][b]);
    }
    return 0;
}