迪杰斯特拉 + 链式前向星 + 优先队列

链式前向星

邻接矩阵存图对于稀疏图（边少）会有很大的空间浪费，这时候防止卡内存，可以用邻接表来存图，但邻接表使用涉及指针，难度较大，可以用数组模拟指针，也就是前向星，但前向星要排序，至少nlogn，而链式前向星可以避免排序操作，降低时间复杂度

前向星博文推荐

作者：sugarbliss
来源：CSDN

链式前向星使用要点

①edge[i].next存同起点的边的上一个点
②head[u]存以u为起点的最后一条输入的边
③head[u] 如果初始化为 -1 那么判断是否还有同起点的边就判断 要edge[i].next 是否 = -1,
④快速判断 i == -1 可以用 ~i
⑤对于无向图 输入的边要 以两个顶点各自为起点都存一边 所以edge[]数组大大小 要申请两倍以上的边的数量

dijstra算法原理

作用：求解单源点无负权边最短路问题

初始时，所有以源点为起点的边中 边权最小的边的终点和源点的距离一定已经是最短了（不用再优化，可以确定下来），因为别的边到源点的边都比这条边的边权长，又没有负边，所以无法对这个最短边的终点进行优化。（所以也很明显这个思想不能用来求最长路，因为初始时与源点最长的边，后面可以被其它边优化的更长。）

基于这一个特点每次都可以选出一个到源点最近的点来优化其它点到源点的距离，优化后这个用来优化其他点距离的点就可以丢掉不管了(因为这个点的边已经尽可能的被优化到最短了），得再选一个到源点最近的点，重复以上过程就可以了完成对所有点的单短路求解。

结合优先队列

上述对最短边的筛选可以用优先队列（最小堆），当然要自己写个排序规则
eg

struct point{   //链式前向星模拟邻接表
    int to;     //作为链式前向星时当做终点，用来堆排序时当做起点入堆
    int w;      //权重
    int next;   //上个同起的边的位置
    bool operator  < (const point &b) const //堆排序规则要反过来
    {
        return w > b.w;
    }
};

存边用链式前向星

例题 公交线路

#include<bits/stdc++.h>
using namespace std;
const int MAX = 1000000;
const int N = 1000000;


struct point{   //链式前向星模拟邻接表
    int to;     //终点
    int w;      //权重
    int next;   //上个同起的边的位置
    bool operator  < (const point &b) const //堆排序规则
    {
        return w > b.w;
    }
};

priority_queue<point> q;
point edge[MAX];//存边
int head[N];
bool vis[N];//判断这个点是否已经确定
int dist[N];//起点到这个点的距离

int cnt = 0;


void addedage(int x,int y,int z){
    edge[cnt].to = y;
    edge[cnt].w = z;
    edge[cnt].next = head[x];
    head[x] = cnt++;
}

bool dijstra(int s,int t){        //s是起点坐标 t是要查寻得点得坐标

    point t1,t2;
    t1.to = s;              //当起点来用
    t1.w = 0;
    dist[s] = 0;
    q.push(t1);

    while(!q.empty()){
        t1 = q.top(); q.pop();
        if(vis[t1.to])  continue;//一个点可能被多次优化 所以会多次进队列
                                //但这个点在堆顶一定是最小的，边就是这个点到起点的最短距离
                                //如果已经确定他的最短距离，就说明已经拿来优化过别的点  
        vis[t1.to] = true;      //表示点已经确定

        for(int i = head[t1.to];~i;i = edge[i].next){//遍历以t1.to为起点的所有可以优化的终点
            int u = edge[i].to;//要优化的终点

            if(!vis[u] && dist[u] > dist[t1.to] + edge[i].w){
                dist[u] = dist[t1.to] + edge[i].w;
                t2.to = u;
                t2.w = dist[u];
                q.push(t2); 
            }
        }
    }
    if(dist[t] >= 0x3f3f3f3f)
        return false;
    return true;
}

int main(){
    int x,y,z;//点1 点2 权值
    int n,m,s,t;
    cin >> n >> m >> s >> t;
    memset(head,-1,sizeof(head));//第一个点没有上一个点
    memset(dist,127,sizeof(dist));//8位最大值 2^7 - 1
   
    for(int i = 0;i < m;i++){   
        cin >> x >> y >> z;
        addedage(x,y,z);
        addedage(y,x,z);//无向图
    }

    if(dijstra(s,t))
        cout << dist[t] << endl;
    else cout << -1 << endl;
    //system("pause");
    return 0;
}

为什么不适用于负边的的例子

起点s，终点t，用dijstra算法可以确定A的最短路是1，但实际上可以用-10的边优化，A实际的最短路是-5，所以有负权边的图不能用dijkstra跑。