优先队列优化的Dijk单源最短路算法

开始以为优先队列优化的是最短路的时间复杂度，现在看来，更多的是优化空间复杂度

我们是先用那个把图变成树的数据结构来存储图中所有的边

如果我们用邻接表储存边的话，空间复杂度为n^2也就是说我们的数组最大能开到5000*5000

现在我们储存边，那么就可以在点较多而边较少的情况下搞定了

下面附上注释详尽的代码

题目：poj3159 这个题目其实是差分约束+Dijk不懂差分约束的话可以看我的差分约束博客

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
#define maxn 50000
#define inf 52100001

using namespace std;

struct Edge
{
    int v,val,next;
};//储存边的数据结构

struct Node//优先队列的数据结构
{
    int poi,val;
    Node(int _val=0,int _poi=0){val=_val;poi=_poi;}
    bool operator <(const Node&r) const//变成小优先队列的好方法
    {
        return val>r.val;
    }
};

//struct node

int head[maxn];
Edge edge[150100];
int Dijks(int en,int beg,int n);

int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        int m;
        scanf("%d",&m);
        memset(head,-1,sizeof(head));

        int be,en,val;
        for (int k=1;k<=m;k++)
        {
            scanf("%d %d %d",&be,&en,&val);
            edge[k].v=en;edge[k].val=val;edge[k].next=head[be];
            head[be]=k;
        }//这个读入就不说了具体解释参见我的把图化成树的博客

        printf("%d\n",Dijks(n,1,n));
    }
    return 0;
}

int Dijks(int en,int beg,int n)
{
    int vis[maxn],dis[maxn];

    memset(vis,0,sizeof(vis));
    for (int i=1;i<=n;i++)
        dis[i]=inf;
    //开始跟一般的Dijk是一样的
    /*
        Dijk算法主要是找到离以加入的点最近的那个点
        把它加进去，并以这个点为中间节点更新dis数组的值
        直到所有的点都加进去
        这时dis[i]就是起点到i点的最短距离了

        用优先队列表示已加入点周围一圈的点集
        因为是周围一圈的，所以满足条件的点一定在这之中
        我们拿出最小的点，也就是第一个进行操作即可
   */
   priority_queue<Node>que;
    dis[beg]=0;//将最开始的dis记为0进行初始化
    que.push(Node(0,beg));//将最开始的点放入优先队列中

    Node save;

    while(!que.empty())//如果队列为空那么所有的点都被访问过了，可以结束循环了
    {
        save=que.top();
        que.pop();//将第首位保存并弹出
        int poi=save.poi;
        if (vis[poi]) continue;//如果首位访问过了，就不管他，这句话其实有点保险的感觉

        vis[poi]=1;//将首位置为访问过
        for (int k=head[poi];k!=-1;k=edge[k].next)//遍历与首位相邻的节点
        {
            int v=edge[k].v;
            int val=edge[k].val;
            if ((!vis[v])&&(dis[v]>dis[poi]+val))//如果没有访问过，那就进行更新（松弛操作）
            {
                dis[v]=dis[poi]+val;
                que.push(Node(dis[v],v));//然后把这个与首位相邻的点放入优先队列中，保证优先队列中的点是以访问过的点的周围一圈
            }
        }
    }
    return dis[en];//返回结果即可
}