最短路-朴素dijkstra(基础算法)

最短路–单源最短路–权为正,稠密图(邻接矩阵)–朴素dijkstra求

源点:起点 汇点:终点
单源最短路,eg:从1号点到n号点最短路
n:点的数量 m:边的数量

朴素Dijkstra:稠密图 n m <1e5 (贪心)
堆优化Dijkstra:稀疏图
SPFA是Bellman-ford算法+(离散数学)的优化,但是对边数进行限制(m<k)就只能用Bellman-Ford算法(动态规划)

难点:把问题抽象想成最短–建图
无向图是一种特殊的有向图

---

题目
给定一个n个点m条边的有向图，图中可能存在重边和自环，所有边权均为正值。

请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出-1。

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

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

数据范围
1 ≤ n ≤ 500
1≤m≤10^5
图中涉及边长均不超过10000

样例输入1
3 3
1 2 2
2 3 1
1 3 4
样例输出1
3

重边:只保留最短的一条边

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int N = 510;//多与点的数量

int n,m;//点,边
int g[N][N];//结点的权重
int dist[N];//最短距离
bool st[N];//最短距离是否确定

int dijkstra()
{
    //初始化
    memset(dist,0x3f,sizeof dist);//求最短路,默认距离为最大值(INF)
    dist[1]=0;//起点的最短距离为0

    for(int i=0; i<n; i++)//n个点循环n遍
    {
        int t = -1;//第一遍t=1,确定第一个结点是最短状态(0到其他点是INF),再用第一个结点更新从第一个结点到其他结点的距离
                   //第二遍点1到其他点的距离都确定了,以除1意外的点都可以做起点
        //确定距离起点最短的点
        for(int j=1;j<=n;j++)//找到st=false && dist最小的点
        
            if(!st[j] &&(t==-1||dist[t]>dist[j]))
                t=j;
        
        st[t] = true;//最短状态确定
        for(int j = 1;j <= n; j ++)//用点t更新t到其他点的距离
            dist[j] = min(dist[j],dist[t]+g[t][j]);
    }
    if(dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}
int main()
{
    cin>>n>>m;
    memset(g, 0x3f, sizeof g);//边长默认最大

    for(int i=0;i<m;i++)//输入方向与权重(边长)
    {
        int a,b,c;
        cin>>a>>b>>c;
        g[a][b]=min(g[a][b],c);//最短路--重边只取最短边
    }

    cout<< dijkstra() <<endl;//最短路--单源最短路--权为正,稠密图(邻接矩阵)--朴素dijkstra求

    return 0;
}

Dijkstra总结:

1. 初始化距离
2. n个点循环n次,每次确定一个状态最短的点
3. 标记该点已经是最短状态
4. 用该点更新它到其他各个点的状态