Dijkstra：正边权单源最短路算法

Dijkstra算法的原理见：有权图的单源最短路算法（Dijkstra算法）

---

图系列专题：

图的深搜，宽搜，判断有向无环图：

• 图的深搜，宽搜，拓扑排序：图的遍历(DFS，BFS，Topology Sort)；

图最短路问题：

• 单源最短路所有边权为正：Dijkstra：正边权单源最短路算法；
• 单源最短路存在负权边：Bellman_Ford和SPFA：带负边权的单源最短路算法；
• 多源汇最短路：Floyd算法：多源汇最短路；

yxc路的最短路相关算法对应场景图：

---

---

朴素Dijkstra算法的实现

AcWing题目见：849. Dijkstra求最短路 I，该算法的时间复杂度为$O(n^2)$，整个的大循环为$n$，同时每次循环当中：

• 寻找剩下(未决)的图的点集中$dist[i]$的最小的点花费时间为$n$；
• 将$st[i]$设置为true，即标记已经解决的时间为$1$；
• 依据$dist[j]$和$dist[i]+g[t][j]$对以点$i$为中继的点进行距离更新的时间为$n$，在大循环中实际更新的次数为边的数目$m$；

所以，由上分析，整个算法的时间复杂度为$O(n^2)$。

---

题目：给定一个 $n$ 个点 $m$ 条边的有向图，图中可能存在重边和自环，所有边权均为正值。请你求出 $1$ 号点到 $n$ 号点的最短距离，如果无法从 $1$ 号点走到 $n$ 号点，则输出 $-1$。

输入格式
第一行包含整数 $n$ 和 $m$。

接下来 $m$ 行每行包含三个整数 $x,y,z$，表示存在一条从点 $x$ 到点 $y$ 的有向边，边长为 $z$。

输出格式
输出一个整数，表示 $1$ 号点到 $n$ 号点的最短距离。

如果路径不存在，则输出 $-1$。

数据范围
$1\le n\le 500,$
$1\le m\le 105,$
图中涉及边长均不超过$10000$。

输入样例：

3 3
1 2 2
2 3 1
1 3 4

输出样例：

3

---

题解：

对于题解中的0x3f3f3f3f的出现，还有对$dist$和$g$数组memset时赋值为0x3f，见：编程中将无穷大常量的设定为0x3f3f3f3f。

#include 
#include 
#include 

using namespace std;

const int N = 510;
int n, m;
int g[N][N], dist[N]; //其中g存储有向边边权，dist[i]表示1到i的最短距离
//题目假定图是稠密图，所以使用了邻接矩阵的数据结构来存储图
bool st[N]; //st[i]记录点i是否已经确定了最短距离

int dijkstra() {
    for(int i = 0; i < n; ++i) { //大循环，对整个图中的所有节点进行遍历
    /****************寻找剩下(未决)的图的点集中$dist[i]$的最小的点******************/
        int t = -1; //设定t=-1
        for(int j = 1; j <= n; ++j)  //对所有的点进行遍历
            if(!st[j] && (-1 == t || dist[t] > dist[j])) 
            //若是（当前点未决）且(节点序号为-1 或 节点到节点1的距离小于当前节点到节点1的距离）
                t = j;
	/****************将当前未决到节点1距离最小的节点t标记为已决*********************/
        st[t] = true; //这里同时可以解决自环的情况
	/**********************更新图中各节点到节点1的最短距离************************/
	//由于Dijkstra算法是基于贪心的算法，所以在遍历过程中，对于在已决点集中的距离是不会进行更新的
        for(int j = 1; j <= n; ++j) 
            dist[j] = min(dist[j], dist[t] + g[t][j]);
    }

	//如果节点n到节点1的距离仍为无穷大，则返回-1，即无法达到
    if(0x3f3f3f3f == dist[n]) return -1;
    //否则返回距离值即可
    return dist[n];
}

int main() {
    memset(g, 0x3f, sizeof(g)); //将邻接矩阵中的所有边的边权设置为无穷大
    memset(dist, 0x3f, sizeof(dist)); //将所有节点到节点1的距离设置为无穷大
    dist[1] = 0; //将节点1的距离设置为0,若是不设置该步骤，则整个算法无法正常运作
    scanf("%d%d", &n, &m);
    for(int i = 0; i < m; ++i) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        g[a][b] = min(g[a][b], c); //这里取较小值是为了筛除重边的情况，若有重边，则选择较小的即可
    }

    int ret = dijkstra();
    printf("%d", ret);

    return 0;
}

---

---

堆优化Dijkstra算法的实现

AcWing题目见：850. Dijkstra求最短路 II，该算法的时间复杂度为$O(mlogn)$。为何可以实现这样的复杂度呢， 在朴素的Dijkstra当中，三个步骤当中最花费时间的操作当属步骤一从未决点集当中寻找到节点$1$最短距离的节点了，若是使用小根堆(根据节点$i$到节点$1$的距离，即$dist[i]$进行堆结构的up，down)这一辅助数据结构，则可以将$O(n)$的时间复杂度减小到$O(1)$，但是步骤三中的进行更改的操作，需要先查找到$i$节点再进行，对于堆结构每次寻找节点的时间开销为$O(logn)$，总共需进行边数$m$次更改操作，所以总的时间复杂度为$O(mlogn)$。

---

题目：给定一个 $n$ 个点 $m$ 条边的有向图，图中可能存在重边和自环，所有边权均为非负值。请你求出 $1$ 号点到 $n$ 号点的最短距离，如果无法从 $1$ 号点走到 $n$ 号点，则输出 $-1$。

输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 $x,y,z$，表示存在一条从点 $x$ 到点 $y$ 的有向边，边长为 $z$。

输出格式
输出一个整数，表示 $1$ 号点到 $n$ 号点的最短距离。
如果路径不存在，则输出 $-1$。

数据范围
$1\le n,m\le 1.5\times 105,$
图中涉及边长均不小于 $0$，且不超过 $10000$。

输入样例：

3 3
1 2 2
2 3 1
1 3 4

输出样例：

3

---

题解：

#include 
#include 
#include 
#include 

using namespace std;

typedef pair<int, int> PII; //pair对，第一个是dist[i]，第二个是i，使用第一个数据进行排序构建小根堆
const int N = 1000010;
int n, m;
int h[N], w[N], e[N], ne[N], idx; //邻接链表对稀疏图进行存储，其中w[i]表示i到e[i]的边的权值
int dist[N]; //dist[i]表示1到i的最短距离
bool st[N]; //st[i]记录点i是否已经确定了最短距离

void add(int a, int b, int c) { //表示添加一有向边，a->b，使用头插法，同时用w[i]记录i到e[i]的边的权值
    e[idx] = b; ne[idx] = h[a]; w[idx] = c; h[a] = idx++;
}

int dijkstra() {
	//创建小根堆，创建方式是固定的，相关的小根堆大根堆的应用可见，数据流的中位数的问题，LeetCode和牛客均有
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    //向堆中加入第一个距离最小的节点，即节点1，它到节点1的距离为0
    heap.push({0, 1});

	//当小根堆不为空，则说明图中边没有遍历完，继续进行遍历
    while(!heap.empty()) {
        PII top = heap.top(); //取出未决点集中和节点1距离最短的节点，时间复杂度O(1)
        heap.pop();

        int t = top.second, d = top.first; //记录下距离最短节点的距离值和节点编号

        if (st[t]) continue; //如果距离已经确定，则跳过该点，这两行代码可省略，因为即便操作了由于已是最小
        st[t] = true; //最短的距离也不会发生改变，作用是将节点t标记为已决

        for(int i = h[t]; i != -1; i = ne[i]) { //对节点t的邻接点进行遍历
            int j = e[i];
            dist[j] = min(dist[j], d + w[i]); //邻接点距离进行更新，更新为较小值，w[i]表示的是t到j的边权值
            if(dist[j] == d + w[i]) heap.push({dist[j], j}); //如果j到1的距离有更改，则将节点j加入到小根堆中去
        }
    }
	
	//如果节点n到节点1的距离仍为无穷大，则返回-1，即无法达到
    if(0x3f3f3f3f == dist[n]) return -1;
    //否则返回距离值即可
    return dist[n];
}

int main() {
    memset(h, -1, sizeof(h)); //将邻接矩阵中的所有边的边权设置为无穷大
    memset(dist, 0x3f, sizeof(dist)); //将所有节点到节点1的距离设置为无穷大
    dist[1] = 0; //将节点1的距离设置为0,若是不设置该步骤，则整个算法无法正常运作

    scanf("%d%d", &n, &m);
    for(int i = 0; i < m; ++i) { //记录图的边权情况
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c); 
        //对于邻接链表存储的图，可以忽略重边的影响，
        //因为在进行更新的时候会更新到最短的那条重边，可以仔细思考一下
        add(a, b, c);
    }

    int ret = dijkstra();
    printf("%d", ret);

    return 0;
}