算法（BFS-＞ Dijkstra求最短路 ）

关于本题用到的0x3f代表无穷的讲解
0x3f3f3f3f

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

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

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

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

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

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

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

输入样例：
3 3
1 2 2
2 3 1
1 3 4
输出样例：
3
原题链接

#include<iostream>
#include<cstring>
using namespace std;
const int N=510;
int g[N][N];//稠密图，邻接矩阵存；稀疏图，邻接表
bool st[N];
int m,n;
int dist[N];
int dijkstra()
{
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;//1号点初始化为0，迭代n次
    for(int i=0;i<n;i++)
    {
        int t=-1;
        for(int j=1;j<=n;j++)
        if(!st[j]&&(t==-1||dist[t]>dist[j]))
        t=j;//第一步，找还没有被访问过的最小值//St判断是否已经确定了最短路/j是，那就把t更新为j
        st[t]=true;
        
        for(int j=1;j<=n;j++)
        dist[j]=min(dist[j],g[t][j]+dist[t]);//用1->t的距离+t->j这条边来更新t->j这条边
        
    }
    if(dist[n]==0x3f3f3f3f)//存在正无穷->不连通
    return -1;
    return dist[n];
    
}
int main()
{
    cin>>n>>m;
    memset(g,0x3f,sizeof g);// 初始化邻接矩阵
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        g[a][b]=min(g[a][b],c);//可能会有重编边，只需要保留长度最短的那条边
    }
    int t=dijkstra();
    printf("%d",t);
}

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

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

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

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

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

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

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

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

原题链接

#include<iostream>
#include<queue>
#include<cstring>

using namespace std;
typedef pair<int,int>PII;//维护堆的时候还需要知道节点编号，所以堆里面存的是pair  
int m,n;
const int N=150010;
int e[N],h[N],ne[N],w[N],idx;//优化版   稀疏图 用邻接表的方式
int dist[N];
bool st[N];

//重边就无所谓了 
void add(int a,int b,int c){
    e[idx]=b;
    w[idx]=c;
    ne[idx]=h[a];
    h[a]=idx++;
}
int dijkstra()
{
   memset(dist,0x3f,sizeof dist);
    dist[1]=0;// 把1号点放进去更新所有的点
    priority_queue<PII,vector<PII>,greater<PII>>heap;
    heap.push({0,1});
    
    while(heap.size())//堆不空，
    {
        auto t=heap.top();
        heap.pop();
        
       int ver=t.second,distance=t.first;// ver表示点的编号dist表示距离
        if(st[ver])continue;
         st[ver]=true;// ver是个冗余 直接跳过，
         //找到当前距离最小的点，
        for(int i=h[ver];i!=-1;i=ne[i])
        {
            int j=e[i];// 更新其他点（遍历这个点的所有边）
            if(dist[j]>distance+w[i])
            {
                dist[j]=distance+w[i];
                heap.push({dist[j],j});//如果大于，就把当前这个点放到堆里面去
            }
        }
        
    }
    if(dist[n]==0x3f3f3f3f)
    return -1;
    return dist[n];
    
    
        
}
int main()
{
    scanf("%d%d",&n,&m);
    memset(h,-1,sizeof h);//  邻接表全部初始化为-1
    while(m--)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
    }
    int t=dijkstra();
    printf("%d\n",t);
    return 0;
}