最短路问题——dijkstra算法

算法思想

Dijkstra算法采用的是一种贪心策略

1.首先声明一个数组dis来保存起始点到各顶点的最短距离。
  再声明一个数组vis，用来标记已经找到的最短经的点。
  设vis是保存已经找到最短路径顶点的集合 Ｔ
  
2.首先从起点开始，每次从待加入 Ｔ 的点中找到一个顶点ｕ，该顶点是与集合
Ｔ距离最近的点，然后将该顶点加入集合Ｔ，更新与该顶点有边的其他顶点ｖ
    ｄ［ｖ］＝ｍｉｎ（ｄ［ｖ］，ｄ［ｕ］＋ｗ（ｕ，ｖ））
    这样更新保证了待加入集合Ｔ中的顶点 v，对应ｄ［v］都是最小值

３.重复２步骤，直到所有顶点都在集合Ｔ中，那么终点ｅ对应的ｄ［ｅ］
	就是最终答案

int dijkstra(){
    memset(dis,0x3f,sizeof dis);
    dis[1]=0;
    for(int i=0;i<n-1;i++){
        int t=-1;
        for(int j=1;j<=n;j++){
            if(!vis[j] && (t==-1 || dis[j]<dis[t]))
                t=j;
        }
        vis[t]=true;
        for(int j=1;j<=n;j++){
            dis[j]=min(dis[j],dis[t]+g[t][j]);
        }
    }
    if(dis[n]==0x3f3f3f3f) return -1;
    return dis[n];
}

优先队列+dijkstra（解决稀疏图）

struct node{
    int now;
    int dis;
    friend bool operator < (node a,node b){
        return a.dis>b.dis;
    }
};
int dijkstra(){
    memset(d,0x3f,sizeof d);
    priority_queue<node>heap;
    d[1]=0;
    heap.push({1,0});
    while(heap.size()){
        auto t=heap.top();
        heap.pop();
        int cur=t.now;
        
        if(vis[cur])continue;
        vis[cur]=true;
        
        for(int i=head[cur];i!=-1;i=ne[i]){
            int j=e[i];
            if(d[j]>d[cur]+w[i]){
                d[j]=d[cur]+w[i];
                heap.push({j,d[j]});
            }
        }
    }
    if(d[n]==0x3f3f3f3f) return -1;
    return d[n];
}