【PAT】最短路径算法Dijkstra模板总结

已于 2024-03-12 10:51:51 修改
阅读量397 收藏 8
点赞数 7
分类专栏： 数据结构与算法 文章标签： 算法 c++ 数据结构
于 2024-01-12 17:23:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50952205/article/details/135557934
版权

目录

模板

#include <iostream>
#define MAX 9999999 // 表示边不存在，用INT32_MAX也可

using namespace std;
int main() {
    int N, M; // 顶点数，边数
    int C1, C2; // 起点，终点
    int A[N][N]; // 记录路径长度

	// 构造邻接矩阵
    cin >> N >> M >> C1 >> C2;
    fill_n(&A[0][0], N * N, MAX); // MAX表示不可达

    for (int i = 0; i < N; i++) cin >> V[i];

    int j, k; // 无向邻接图对称！
    for (int i = 0; i < M; i++) {
        cin >> j >> k >> A[j][k];
        A[k][j] = A[j][k];
    }

    // 最短路径算法
    int visit[N]; // 记录是否在点集中
    int D[N]; // 记录C1到点i的最短路径
    int min, v, w;

    // 初始化（直通路径初始化）
    for (int i = 0; i < N; i++) {
        visit[i] = 0; 
        D[i] = A[C1][i]; // 记录直通的路径长
    }

    visit[C1] = 1; // C1加入已访问节点
    D[C1] = 0; // C1到C1路径长为0
    for (int i = 1; i < N; i++) { // N-1轮
        min = MAX;
        v = -1;
        for (w = 0; w < N; w++) {
            if (!visit[w]) {
                if (D[w] < min) {
                    v = w;
                    min = D[w];
                }
            }
        }
        if (v == -1) break;
        visit[v] = 1;
        for (w = 0; w < N; w++) { //加入w节点，处理D[w]
            if (!visit[w] && A[v][w] != MAX) { // 访问未访问且有直通路径的节点w
                if (min + A[v][w] < D[w]) { // 如果当前记录的最短路径大于经过v的路径
                    D[w] = min + A[v][w]; // 更新D[w]
                } 
            }
        }
    }
}

应用

参考《算法笔记》与《算法笔记-上机训练实战指南》，柳婼大神的博客

PAT1003

#include <iostream>
#define MAX 9999999

using namespace std;
int main() {
    int N, M;
    int C1, C2;
    int V[N]; // 记录每个城市的救援队数量
    int A[N][N]; // 记录路径长度

    cin >> N >> M >> C1 >> C2;

    fill_n(&A[0][0], N * N, MAX); // MAX表示不可达

    for (int i = 0; i < N; i++) cin >> V[i];

    int j, k; // 无向邻接图对称！
    for (int i = 0; i < M; i++) {
        cin >> j >> k >> A[j][k];
        A[k][j] = A[j][k];
    }

    // 最短路径算法
    int visit[N]; // 记录是否在点集中
    int D[N]; // 记录C1到点i的最短路径
    int W[N]; // 记录C1到点i救援队伍数量
    int count[N]; // 记录C1到点i最短路径数
    int min, v, w;

    // 初始化（直通路径初始化）
    for (int i = 0; i < N; i++) {
        visit[i] = 0; 
        D[i] = A[C1][i]; // 记录直通的路径长
        if (A[C1][i] != MAX) W[i] = V[C1] + V[i]; // 记录直通连接的路径权值
        else W[i] = 0;
        count[i] = 1; // C1到i肯定有一条路径
    }

    visit[C1] = 1; // C1加入已访问节点
    D[C1] = 0; // C1到C1路径长为0
    W[C1] = V[C1];
    for (int i = 1; i < N; i++) {
        min = MAX;
        v = -1;
        for (w = 0; w < N; w++) {
            if (!visit[w]) {
                if (D[w] < min) {
                    v = w;
                    min = D[w];
                }
            }
        }
        if (v == -1) break;
        visit[v] = 1;
        for (w = 0; w < N; w++) { //加入w节点，处理D[w],W[w],count[w]
            if (!visit[w] && A[v][w] != MAX) { // 访问未访问且有直通路径的节点w
                if (min + A[v][w] < D[w]) { // 如果当前记录的最短路径大于经过v的路径
                    D[w] = min + A[v][w]; // 更新D[w]
                    count[w] = count[v]; // 更新count[w]
                    W[w] = W[v] + V[w]; // 更新W[w]
                } else if (min + A[v][w] == D[w]) { // 如果当前记录的最短路径等于经过v的路径
                    count[w] = count[w] + count[v]; // 累加上经过v到达w的路径数
                    if (W[w] < W[v] + V[w]) W[w] = W[v] + V[w]; // 更新W[w]
                }
            }
        }
    }
    
    printf("%d %d", count[C2], W[C2]);
}

PAT1018

这题和上一题不同之处在于，此题不能使用单纯的dijkstra，要配合dfs。因为这题minNeed与minRemain不满足最优子结构，即无法边进行路径传递边求的结果，只有当全部路径确定后才能去得到最优答案。（有点玄玄的-。-）
dijkstra：求所有最短路径
dfs：在所求的所有的最短路径上遍历得到最优解

#include <iostream>
#include <vector>
#include <algorithm>
#define MAX 999999
#define MAXV 510

using namespace std;

// 初始数据
int C, N, Sp, M; // 车站最大容量， 车站总数，问题车站序号，边数
int c[MAXV]; // 每个车站包含的单车数
int T[MAXV][MAXV]; // 记录边描述的时间
int Si, Sj, edge;
// 最短路径算法 + DFS
int visit[MAXV];
int D[MAXV];
int mini, v, w;
vector<int> pre[MAXV]; // 记录顶点前驱
vector<int> tempPath, path; // 记录临时路径及最优路径
int minNeed = MAX, minRemain = MAX; // 最少需要补和还的单车数量

void Dijkstra() {
	// 初始化
    for (int i = 0; i <= N; i++) {
        D[i] = T[0][i];
        visit[i] = 0;
        if (T[0][i] != MAX) pre[i].push_back(0);  // 前驱初始化
    }

    visit[0] = 1;
    D[0] = 0;
    for (int i = 1; i <= N; i++) {
        mini = MAX;
        v = -1;
        for (int w = 0; w <= N; w++) {
            if (!visit[w]) {
                if (D[w] < mini) {
                    v = w;
                    mini = D[w];
                }
            }
        }
        
        if (v == -1) break;
        visit[v] = 1;

        for (int w = 0; w <= N; w++) {
            if (!visit[w] && T[v][w] != MAX) {
                if (T[v][w] + D[v] < D[w]) { // 更新最短路径的同时更新前驱
                    D[w] = T[v][w] + D[v];
                    pre[w].clear(); // 换路径了，清空
                    pre[w].push_back(v);
                } else if (T[v][w] + D[v] == D[w]) {
                    pre[w].push_back(v); // 更新，但不请空原有路径
                }
            }
        }
    }
}

// 依次处理时间花费相同的最短路径
void DFS(int v) {
    if (v == 0) { // 递归边界
        // 计算一条路径PBMC要补和收回的自行车数
        tempPath.push_back(v); 
        int need = 0, remain = 0;
        for (int i = tempPath.size() - 2; i >= 0; i--) {
            int id = tempPath[i];
            if (c[id] > 0) { // 说明自行车要带走一部分
                remain += c[id];
            } else { // 反之说明自行车要补一部分
                if (remain < abs(c[id])) { // 不够补，则PBMC要补一部分
                    need += abs(c[id]) - remain;
                    remain = 0;
                } else {
                    remain -= abs(c[id]);
                }
            }
        }

        // 比较得出最优解
        // 条件一：PBMC补出的自行车数最少
        // 条件一相等则考虑条件二：PBMC收回的自行车数最少
        // 题目描述是在最短路径的基础上，考虑条件一，输出时若还有多条路径，考虑条件二
        if (need < minNeed) {
            minNeed = need;
            minRemain = remain;
            path = tempPath; 
        } else if (need == minNeed && remain < minRemain){
            minRemain = remain;
            path = tempPath;
        }

        tempPath.pop_back();
        return;
    }

    tempPath.push_back(v);
    for (int i = 0; i < pre[v].size(); i++) {
        DFS(pre[v][i]);
    }
    tempPath.pop_back();
}

int main() {
    cin >> C >> N >> Sp >> M;
    
    for (int i = 1; i <= N; i++) {
        cin >> c[i];
        c[i] -= C / 2; // 减去车站一半单车，方便判断要补还是还
    }

    fill(T[0], T[0] + MAXV * MAXV, MAX);
    
    for (int i = 0; i < M; i++) {
        cin >> Si >> Sj >> edge;
        T[Si][Sj] = edge;
        T[Sj][Si] = edge;
    }

    // 最短路径算法
    Dijkstra();

    // DFS
    DFS(Sp);

    cout << minNeed << " ";
    for (int i = path.size() - 1; i >= 0; i--) {
        if (i != 0) cout << path[i] << "->";
        else cout << path[i] << " ";
    }
    
    cout << minRemain;
    
    return 0; 
}

PAT1030

这题比上面那题简单，只使用Dijkstra即可
关于路径的描述，上面那题因为要记录全部的最短路径，一个顶点可能对应多个前驱，所以pre采用vector数组来描述，而此题可以一边寻找最短路径一边计算cost，更换最短路径，同时记录一条即可，所以采用int数组描述。

#include <iostream>
#include <vector>
#define MAXV 500
#define Inf 999999

using namespace std;

int N, M, Si, Di; // 城市数量，高铁数量，起点，终点
int Distance[MAXV][MAXV], Cost[MAXV][MAXV]; // 记录城市之间距离和花费

int visit[MAXV];
int D[MAXV];
int pre[MAXV];
vector<int> path;
int C[MAXV]; // 记录到达该点处所需要最少的费用
int v, w, mini;

void Dijkstra() {
    for (int i = 0; i < N; i++) {
        visit[i] = 0;
        D[i] = Distance[Si][i];
        if (Distance[Si][i] != Inf) {
            pre[i] = Si;
            C[i] = Cost[Si][i];
        }
    }

    visit[Si] = 1;
    D[Si] = 0;
    for (int i = 1; i < N; i++) {
        mini = Inf;
        v = -1;
        for (int w = 0; w < N; w++) {
            if (!visit[w] && D[w] < mini) {
                v = w;
                mini = D[w];
            }
        }

        if (v == -1) break;
        visit[v] = 1;

        for (int w = 0; w < N; w++) {
            if (!visit[w] && Distance[v][w] != Inf) {
                if (mini + Distance[v][w] < D[w]) {
                    D[w] = mini + Distance[v][w];
                    C[w] = C[v] + Cost[v][w];
                    pre[w] = v;
                } else if (mini + Distance[v][w] == D[w]) {
                    if (C[v] + Cost[v][w] < C[w]) {
                        C[w] = C[v] + Cost[v][w];
                        pre[w] = v;
                    }
                }
            }
        }
    }
}

int main() {
    cin >> N >> M >> Si >> Di;

    fill(Distance[0], Distance[0] + MAXV * MAXV, Inf);
    fill(Cost[0], Cost[0] + MAXV * MAXV, Inf);

    int City1, City2;
    for (int i = 0; i < M; i++) {
        cin >> City1 >> City2 >> Distance[City1][City2] >> Cost[City1][City2];
        Distance[City2][City1] = Distance[City1][City2];
        Cost[City2][City1] = Cost[City1][City2];
    }

    Dijkstra();

    int w = Di;
    while (w != Si) {
        path.push_back(w);
        w = pre[w];
    }
    path.push_back(w);

    for (int i = path.size() - 1; i >= 0; i--) {
        cout << path[i] << " ";
    }

    cout << D[Di] << " " << C[Di];
    
}

PAT1072

条件很多，主要是输入处理有些麻烦，运行测试用例时五舍六入，3.25->3.2，然后发现平台提交后也是正确的，好坑= =

#include <iostream>
#include <string>
#define MAXV 1020
#define Inf 999999

using namespace std;

/*
把不同的煤气站分别作为起点，进行最短路径求解，期间某所房子与该煤气站超过最大距离时排除，
最后进行比较，哪一煤气站距离任意房子的最短路径最大，若有并列情况，选择输出与所有房子平均最短路径最小的，
若仍有并列情况，输出编号更小的。
    */
int N, M, K, Ds; // 房子总数，煤气站候选点总数，连接房子与煤气站之间路的数量，煤气站的最大服务范围
string P1, P2;
int Dist;
int V; // 房子+煤气站
int Distance[MAXV][MAXV]; 

// 进行最短路径
int mini, v, w;
int D[11][MAXV];
int visit[MAXV];
int D_min; // 记录与任意房子的最短距离中最小值
int best = 0; // 最后选出的候选点
double Avg_min[11] = {0.0}; // 记录平均最短路径
double Any_max[11] = {0.0}; // 记录与任意房子的最短距离尽可能远的距离

void Dijkstra(int s) {
    for (int i = 1; i <= V; i++) {
        visit[i] = 0;
        D[s][i] = Distance[s][i];
    }

    visit[s] = 1;
    D[s][s] = 0;
    D_min = Inf;
    for (int i = 1; i < V; i++) {
        mini = Inf;
        v = -1;
        for (int w = 1; w <= V; w++) {
            if (!visit[w]) {
                if (D[s][w] < mini) {
                    v = w;
                    mini = D[s][w];
                }
            }
        }

        if (v == -1) break;
        visit[v] = 1;
        
        if (v > M) {
            if (Ds < D[s][v]) { // 某所房子超过最大距离，该点排除
                D_min = -1;
                break; 
            }
            if (D[s][v] < D_min) D_min = D[s][v];
            Avg_min[s] += 1.0 * D[s][v];
        }
        
        for (int w = 1; w <= V; w++) {
            if (Distance[v][w] != Inf && mini + Distance[v][w] < D[s][w]) {
                D[s][w] = mini + Distance[v][w];
            }
        }
    }

    Avg_min[s] = Avg_min[s] / N;
    Any_max[s] = D_min;
}

int main() {
    cin >> N >> M >> K >> Ds;
    V = N + M;

    fill(Distance[0], Distance[0] + MAXV * MAXV, Inf);

    int id1, id2;
    for (int i = 0; i < K; i++) {
        cin >> P1 >> P2 >> Dist;
        if (P1[0] == 'G') {
            id1 = stoi(P1.substr(1, P1.length() - 1));
        } else {
            id1 = stoi(P1) + M;
        }
        if (P2[0] == 'G') {
            id2 = stoi(P2.substr(1, P2.length() - 1));
        } else {
            id2 = stoi(P2) + M;
        }
        Distance[id1][id2] = Dist;
        Distance[id2][id1] = Dist;
    }

    for (int s = 1; s <= M; s++) {
        Dijkstra(s);
    }

    double temp = 0.0;
    for (int s = 1; s <= M; s++) {
        if (Any_max[s] == -1) continue;
        if (temp < Any_max[s]) {
            temp = Any_max[s];
            best = s;
        } else if (temp == Any_max[s] && Avg_min[s] < Avg_min[best]) {
            best = s;
        }
    }

    if (best == 0) cout << "No Solution";
    else {
        cout << "G" << best << endl;
        printf("%.1f %.1f", Any_max[best], Avg_min[best]);
    }

}

PAT1087

这题就比较简单点，就是要计算的条件太多，Dijkstra和Dijkstra+DFS都可。
总结套路：
PAT考试一般计算最短路径，最短路径数量，点权值，平均点权值，除了第二道需要看到全部路径才可以计算得出之外，这些都可以通过简单累加得出结论（最优子结构，即大问题分解为小问题）√
输入输出需要稍微处理。
path通过pre计算得出。

#include <iostream>
#include <string>
#include <vector>
#define MAXV 200
#define Inf 999999

using namespace std;

// 条件一：最短cost
// 若条件一得出路径不唯一，条件二：最大快乐值
// 若条件二依旧不唯一，条件三：最大平均快乐值

int N, K; // 城市数量，路数量
string City1, City2;
int cost;
string Cmap[MAXV]; // 记录城市名与编号的映射
int Happiness[MAXV]; // 城市代表的快乐值
int Cost[MAXV][MAXV]; // 城市间的路费

// 最短路径算法
int mini, v, w;
int D[MAXV]; 
int H[MAXV]; // 到达该城市时最大快乐值
int Num[MAXV]; // 到达该城市时需要的最少城市数量
int count[MAXV]; // 到达该城市的最短路径数
int visit[MAXV];
int pre[MAXV];

void Dijkstra() {
    fill(Num, Num + MAXV, Inf);
    fill(count, count + MAXV, 1);
    for (int i = 1; i < N; i++) {
        visit[i] = 0;
        D[i] = Cost[0][i];
        if (Cost[0][i] != Inf) {
            H[i] = Happiness[i];
            pre[i] = 0;
            Num[i] = 1;
        }
    }

    D[0] = 0;
    H[0] = 0;
    Num[0] = 0;
    visit[0] = 1;
    for (int i = 1; i < N; i++) {
        mini = Inf;
        v = -1;

        for (int w = 0; w < N; w++) {
            if (!visit[w]) {
                if (D[w] < mini) {
                    mini = D[w];
                    v = w;
                }
            }
        }

        if (v == -1) break;
        visit[v] = 1;

        for (int w = 0; w < N; w++) {
            if (!visit[w] && Cost[v][w] != Inf) {
                if (mini + Cost[v][w] < D[w]) {
                    D[w] = mini + Cost[v][w];
                    H[w] = H[v] + Happiness[w];
                    count[w] = count[v];
                    Num[w] = Num[v] + 1;
                    pre[w] = v;
                } else if (mini + Cost[v][w] == D[w]) {
                    count[w] += count[v];
                    if (H[w] < H[v] + Happiness[w]) {
                        H[w] = H[v] + Happiness[w];
                        Num[w] = Num[v] + 1;
                        pre[w] = v;
                    } else if (H[v] + Happiness[w] == H[w] && Num[v] + 1 < Num[w]) {
                        Num[w] = Num[v] + 1;
                        pre[w] = v;
                    }    
                }
            }
        }
    }
}

int main() {
    cin >> N >> K >> Cmap[0];

    // 建立映射
    fill(Happiness, Happiness + MAXV, Inf);
    Happiness[0] = 0;
    for (int i = 1; i < N; i++) {
        cin >> Cmap[i] >> Happiness[i];
    }

    fill(Cost[0], Cost[0] + MAXV * MAXV, Inf);
    int id1, id2;
    for (int i = 0; i < K; i++) {
        cin >> City1 >> City2 >> cost;
        for (int j = 0; j < N; j++) {
            if (Cmap[j] == City1) id1 = j;
            if (Cmap[j] == City2) id2 = j;
        }
        Cost[id1][id2] = cost;
        Cost[id2][id1] = cost;
    }

    Dijkstra();

    int e;
    for (int i = 1; i < N; i++) {
        if (Cmap[i] == "ROM") {
            e = i;
            break;
        }
    }

    // for (int i = 1; i < N; i++) {
    //     cout << count[i] << " ";
    // }

    vector<string> path;
    int v = e;
    while (v != 0) {
        path.push_back(Cmap[v]);
        v = pre[v];
    }
    path.push_back(Cmap[v]);
    
    printf("%d %d %d %d\n", count[e], D[e], H[e], H[e]/(path.size() - 1));
    for (int i = path.size() - 1; i >= 0; i--) {
        cout << path[i];
        if (i != 0) cout << "->";
    }
}
海心巧克力
关注
  • 7
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
最短路径 Dijkstra算法C语言实现
11-13
本设计以VC++6.0作为程序开发环境，C语言作为程序开发语言，详细介绍了最短路径的求解算法及其C语言实现过程。系统主要实现了图的创建、单源点最短路径的计算功能。依照本系统可以解决实际生活中许多路径选择问题，比如交通旅游、城市规划以及电网架设等等。系统性能稳定，适应性强，界面清晰，操作简单，适合用户使用。 课程设计要求： 最短路径问题已经被应用到GIS、GPS等信息管理系统中，为人们生活带来了很大便利。它属于图结构问题，其解决方法也有不少（如Dijkstra、 A-star）。单源点最短路径问题解决的是既定起点的情况下，寻求该点到图中其它顶点的最短路径。请用C/C++语言的结构体、指针、数据结构等基础知识，编写程序实现图的结构定义、图的存储，以及求解单源点最短路径。
最短路径算法Dijkstra源代码
06-22
最短路径算法Dijkstra源代码，测试可以正常使用
图论最短路径 Dijkstra算法和模板
I am coming！
10-06 2949
From：http://blog.sina.com.cn/s/blog_61533c9b0100iaj4.html Dijkstra算法是用来求单源最短路径的算法。时间复杂度O（N^2）； 注意：1，不能求含有负权的图，含有负权可以采用Bellman-ford和S
最短路径 Dijkstra算法（模板）
Change the world by program.
02-03 312
计算最短路径的基础算法，Dijkstra算法基础模板 const int inf = 0x3f3f3f3f; const int maxn = 1050; struct Edge { int from, to, dist; Edge(int f, int t, int d) :from(f), to(t), dist(d) {} }; struct HeapNode { ...
dijkstra 最短路径算法模板
@fei
02-25 1190
单源最短路径dijkstra算法，使用优先队列优化
模板_Dijkstra最短路径算法
李静静
04-19 240
//初始化dis数组，这里是1号顶点到其余各个顶点的初始路程 for(i = 1;i <= n;i ++) dis[i]=e[1][i]; book[1]=1; //Dijkstra算法核心语句 for(i = 1;i <= n-1;i ++) { min = inf; for(j = 1;j <= n;j ++) { if(!book[
最短路径算法dijkstra的matlab实现_dijkstra_最短路径算法_
10-04
最短路径算法dijkstra的matlab实现
Dijkstra最短路径算法的Matlab实现
08-23
Dijkstra最短路径算法的Matlab实现 包括最短路径的打印子程序
并行最短路径算法Dijkstra
04-21
并行最短路径算法Dijkstra。 为实现并行最短路径计算，我们必须要解决如下问题： （1）数据获取：利用随机函数生成大约2000个节点及其节点之间的距离。本程序使用邻接矩阵来存储带权有向图的信息。矩阵大小2000*2000...
最短路径算法dijkstra的matlab程序
08-07
最短路径算法dijkstra的matlab程序。
图的最短路径算法Dijkstra算法模板
Lucky小黄人的博客
09-09 162
Dijkstra算法：伪代码 1 //G为图，一般设为全局变量，数组d[u]为原点到达个点的额最短路径， s为起点 2 Dijkstra(G, d[u], s){ 3 初始化； 4 for (循环n次){ 5 u = 是d[u]最小的且还未访问的顶点的标号; 6 记u已经被访问; 7 for (从u出发能到达...
【模板】单源最短路径（Dijkstra算法）
zjgmartin的博客
09-06 181
前往：我自己搭建的博客 题目 洛谷P4779【模板】单源最短路径（标准版） 题解 链式前向星（存边结构）：与链表的结构和查找遍历方式相同，唯一的不同点就是插入的位置。链式前向星每次将新的元素插入链表头。为每一个节点建立一个链表，存入此节点的所有出边。 Dijkstra算法:这个算法要求所有边的权重都为非负值。定义d[i]为从起点到第i个节点的最短路径长度。 算法流程：假设起点为s。1.令d[s]=0 ,其它d[i]为无穷大 2.从没有被标记的节点中找出d[x]最小的节点x，然后标记x 3.枚举x
最短路径（Dijkstra模板）
MInNrz的Love&Share
08-02 2432
打一个dj的模板，方便以后查阅 #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;cstring&gt; using namespace std; const int MAX=1e9; int n,m; int a[1005][1005];//图 int lowcost[1005]; int vis[1005]; v...
最短路径dijkstra模板
zhaoGavin的博客
05-15 554
题目描述 第一行两个整数n m。n表示顶点个数（顶点编号为1~n），m表示边的条数。接下来m行表示，每行有3个数x y z。表示顶点x到顶点y边的权值为z。求源点为1的最短路径。 题目来源【坐在马桶上看算法】算法7：Dijkstra最短路算法 题目思路 这道题我只是想练练dijkstra模板，dijkstra主要由两个步骤组成： 找到顶点 i 周围距离最近的点 u 将u 加入集合...
最短路径-dijkstra模板
qq_54196808的博客
04-07 191
单源最短路径问题：求从起点到任一点的最短距离或指定点到任意一点的最短距离
最短路径模板（dijkstra,floyed）
xx_ii
07-30 749
n个点，m条边，给定起点和终点，求单源最短路径。 dijkstra算法： #include&amp;amp;amp;amp;amp;amp;lt;bits/stdc++.h&amp;amp;amp;amp;amp;amp;gt; #define inf 0x3f3f3f3f #define maxn 100 #define sf scanf #define pf printf using namespace std; int n,m,x,y,z; //n个城市和m条道路 int mp[
[转]最短路径算法—Dijkstra(迪杰斯特拉)算法分析与实现
heiyeluren的blog（黑夜路人的开源世界）
10-21 4899
最短路径算法—Dijkstra(迪杰斯特拉)算法分析与实现
迪杰斯特拉(Dijkstra)算法
热门推荐
xiaoxi_hahaha的博客
11-29 7万+
一 算法介绍 迪杰斯特拉算法是由荷兰计算机科学家在1956年发现的算法，此算法使用类似广度优先搜索的方法解决了带权图的单源最短路径问题。它是一个贪心算法。 二 核心思想 1. 选定一个点，这个点满足两个条件：1.未被选过，2.距离最短 2. 对于这个点的所有邻近点去尝试松弛 三 算法步骤 首先，可以设置两个集合分别是A和B，A用来存放已经求出最短路径的点，B用来存放还未计算出最短路径的点，接下来就可以开始做题啦！！！ 我们从图中任选一点来解题，假设我们将源点source选择..
Dijkstra模板详解（适合完全不懂的小白）
最新发布
chen1254646的博客
09-01 272
这里用t来作为后面for循环的一个判断条件，因为后面for循环中当第一个进入判断时，t作为当前的在所有最短路径中最短的，然后不断更新，找到最后，就找到了，从起点到任一点的最短距离中最短的，然后st[t]=true，表示已经拿出来用过了，后面一个for循环应该很好理解，就是更新所有从起点到任一点的最短距离，因为，你找到了起点到t距离最短，那其他点经由t作为中转点，就能算出从起点到任一点的最短距离的另一结果，再跟原本的比较，取消的，循环n次，最后就是所要求的。重复2、3步骤，直到所有节点的最短路径长度被确定。
最短路径算法dijkstra算法代码
06-28
抱歉，我是AI语言模型，无法提供代码。以下是Dijkstra算法的伪代码： ...3. 返回起点s到终点t的最短路径。 Dijkstra算法的时间复杂度为O(n^2)，可以通过使用优先队列来优化到O(mlogn)，其中n为节点数，m为边数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值