最短路径模板——dijkstra算法

稠密图

稠密图采用邻接矩阵存储：
g[i][j]=x，表示i->j的距离为x

题目描述
给定一个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⁵,
图中涉及边长均不超过10000。

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

看数据范围：
n个顶点，有向图最多n×(n-1)条)<不考虑重边、自环>，n²等于2.e5，m等于1e5，m和n²一个级别，是稠密图，采用临界矩阵存储。

//#include 
//有向带权图
//图中存在重边和自环  自环：自己直接指向自己
//适合稠密图，用邻接矩阵存储

#include 
#include 

using namespace std;

const int N=510;
int g[N][N],dis[N];
bool vis[N];//判断该结点是否已加入距离1号结点最近的结点的集合
int n,m; //n个点 m条边

int dijkstra()//处理1->n号结点的最短路径
{
     
    memset(dis,0x3f,sizeof dis);
    dis[1]=0; //1号结点到1号结点的距离为0
    //最多循环n次，每次选出一个距离1号结点最近的结点，可求出每个结点到1号结点的距离
    int num=n;
    while (num--) {
     
        int t=-1;//初始化该结点不存在
        for (int i = 1; i <= n; ++i) {
     
            if (!vis[i] && (t==-1||dis[i]<dis[t]))  t=i;
        }   //选出来的dis[t]数组的值是递增的
        if (t==n)  break; //此时到了最后一个结点，但是不能确定dis[t]的值是不是无穷大，设想一下：n个顶点，0条边的情况
        vis[t]=true;
        for (int i = 1; i <= n; ++i) {
      //更新距离
            dis[i]=min(dis[i],dis[t]+g[t][i]); //自环权值为正，肯定要加上一个距离，必然小于，所以自环可忽略
        }                                      //min(dis[i],dis[i]+g[i][i])
    }
    if (dis[n]==0x3f3f3f3f)  return -1;
    return dis[n];
}

int main() {
     
    cin>>n>>m;
    //初始化邻接矩阵
    memset(g,0x3f,sizeof g);
    for (int i = 1; i <= n; ++i)  g[i][i]=0; //规定自身到自身距离为0，自环的边无效
    //存储边
    int a,b,c;
    while (m--) {
     
        cin>>a>>b>>c;
        g[a][b]=min(g[a][b],c);//处理重边的情况，取最小值的边，同时忽略自环
    }
    
    cout<<dijkstra();
    
    return 0;
}

当数据范围是
1≤n,m≤1.5×10⁵ ,
图中涉及边长均不小于0，且不超过10000。

m和n是一个级别的，是稀疏图，采用邻接表存储，堆优化。

//#include 
//适合稀疏图，堆优化的dijkstra，用邻接表存储

#include 
#include 
#include 

using namespace std;

typedef pair<int,int> PII; //first表示距离，second表示节点编号，按first升序排列
const int N=2e5+10; //1≤n,m≤1.5×10^5
priority_queue< PII,vector<PII>,greater<PII> > heap;
int h[N],e[N],w[N],ne[N],idx;
int dis[N];
bool vis[N]; //判断结点是否已经被加入最近的点集合
int n,m;

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

int dijkstra()
{
     
    memset(dis,0x3f,sizeof dis);
    dis[1]=0;

    heap.push({
     0,1});
    while (heap.size()) {
     
        auto t=heap.top();
        heap.pop();

        int v=t.second,d=t.first;
        if (vis[v]) continue;
        vis[v]= true;
        for (int i = h[v]; i != -1; i=ne[i]) {
     
            int j=e[i];//边t->j
            if (d+w[i]<dis[j]) {
     //如果之前已经加入集合的点这里会过滤掉的，d+w[i]必大于dis[e[i]]
                dis[j]=d+w[i]; //因为t后于e[i]加入集合，所以d>=dis[e[i]],所以这里不需要!vis[j]的判断
                heap.push({
     dis[j],j});
            }   //这里最好是用替换结点j，但是stl中的堆只能插入，不能替换结点j的距离，所以势必会造成
        }      //堆中有一些冗余元素：同一个j结点，有更新完的距离和若干更新前的距离，但却不用手写堆了
    }          //所以引入了vis的bool数组，额外判断是否已经更新过，属于最短距离的点的集合了
    if (dis[n]==0x3f3f3f3f)  return -1;
    return dis[n];
}

int main() {
     
    memset(h,-1,sizeof h);
    cin>>n>>m;
    int a,b,c;
    while (m--) {
     
        cin>>a>>b>>c; //a->b 距离为c
        add(a,b,c);
    }
    cout<<dijkstra();
    return 0;
}