最短路（dij+优先队列优化）模板

最短路径问题描述

有n个城市，求s到e的最短路径；

算法解析 dij（算法）时间复杂度（n2）；

当n的值较小时，直接用（dij）算法没有问题，但是当数值较大或者访问过多时就需要优化；
算法思想：贪心，从起点开始，不断的寻找不同点到起始点的最短距离；
链接一篇博客：https://blog.csdn.net/swustzhaoxingda/article/details/84318570
添加链接描述

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#include<cmath>
#include<vector>
using namespace std;
const int N=1e3;
const int inff=0x3f3f3f3f;
int dis[N],head[N];
bool p[N];
int cnt=0;
struct node{          // 链式向前星建边；
    int to,val;
    int next;
}edge[N*10];
void add(int x, int y, int val)      // 建边；
{
    edge[cnt].to=y;
    edge[cnt].val=val;
    edge[cnt].next=head[x];
    head[x]=cnt++;
    edge[cnt].to=x;
    edge[cnt].val=val;
    edge[cnt].next=head[y];
    head[y]=cnt++;
}
void dij(int n, int s)
{
    int m,i,j,to,val;
    dis[s]=0;               // 起点置0；
    for(i=0;i<n;i++){
        m=-1;                // 设置一个初值；
        for(j=1;j<=n;j++){        // 注意j是从1开始的；
            if(p[j])                 // 判断是否已经被处理过；
                if(m==-1||dis[m]>dis[j])
                m=j;
        }
        if(dis[m]==inff)
            break;
        p[m]=false;
        for(j=head[m];j!=-1;j=edge[j].next){
            to=edge[j].to;
            val=edge[j].val;
            if(dis[to]>dis[m]+val)       // 将这个位置的距离转化的更小；
                dis[to]=dis[m]+val;
        }
    }
}
int main()
{
    int n,m,s,e,i,x,y,val;
    memset(head,-1,sizeof(head));
    memset(dis,inff,sizeof(dis));
    memset(p,true,sizeof(p));
    scanf("%d%d%d%d",&n,&m,&s,&e);
    for(i=0;i<m;i++){
        scanf("%d%d%d",&x,&y,&val);
        add(x,y,val);
    }
    dij(n,s);
    if(dis[e]>=inff)               // 路不存在；
        printf("-1\n");
    else
        printf("%d\n",dis[e]);
    return 0;
}

second（dij+优化）n*logn；

从上面的代码中我们可以看出时间浪费在了查找剩余最小的dis[]上；
所以我么要做的就是使用优先队列消去这一浪费；

#inlcude<bits/c++std.h>
using namespace std;
const int N=1e5;
const int inff=0x3f3f3f3f;
int head[N],dis[N];
int cnt;
bool p[N];
struct node{
    int to,next,val;
}mp[N];
struct nod{
    int rt,val;
    bool friend operator <(nod a, nod b)
    {
        return a.val>b.val;
    }
};
void add(int x, int y, int val)
{
    mp[cnt].to=y;
    mp[cnt].val=val;
    mp[cnt].next=head[x];
    head[x]=cnt++;
    mp[cnt].to=x;
    mp[cnt].val=val;
    mp[cnt].next=head[y];
    head[y]=cnt++;
}
int dij(int n, int s)
{
    int val,rt,to;
    priority_queue<nod >q;
    dis[s]=0;
    q.push(nod{s,dis[0]});
    while(!q.empty()){
        nod are=q.top();
        q.pop();
        rt=are.rt;
        if(!p[rt]) continue;
        p[rt]=false;
        for(register int i=head[rt];~i;i=mp[i].next){
            to=mp[i].to;
            val=mp[i].val;
            if(dis[to]>dis[rt]+val){
                dis[to]=dis[rt]+val;
                q.push(nod{to,dis[to]});
            }
        }
    }
    if(dis[n]==inff) return -1;
    return dis[n];
}
int main()
{
    int n,m,x,y,val;
    while(scanf("%d%d",&n,&m)!=EOF&&(n+m)){
            cnt=1;
        memset(head,-1,sizeof(head));
        memset(p,true,sizeof(p));
        memset(dis,inff,sizeof(dis));
        for(register int i=0;i<m;++i){
            scanf("%d%d%d",&x,&y,&val);
            add(x,y,val);
        }
        printf("%d\n",dij(n,1));
    }
    return 0;
}