最短路-朴素版Dijkstra算法&堆优化版的Dijkstra

朴素版Dijkstra

目标

找到从一个点到其余点的最短距离

思路

①初始化距离dist数组，将起点dist距离设为0，其余点的距离设为无穷（就是很大的值）

②for循环遍历n次，每层循环里找出不在S集合中，且距离最近的点，而后用该点去更新其余点的距离，算法复杂度是O（n²），适合稠密图

实例练习

题目：https://www.acwing.com/problem/content/851/

代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=550;

int n,m;
int g[maxn][maxn];
int dist[maxn];
bool st[maxn];

int Dijkstra()
{
    int i,j;
    //初始化距离为无穷大
    memset(dist,0x3f,sizeof(dist));
    //起点距离为1
    dist[1]=0;
    //循环n次，就能够将全部点都加入到集合里
    for(i=1;i<=n;i++)
    {
        //用来记录，不在S集合中，距离最近的点
        int t=-1;
        for(j=1;j<=n;j++)
        {
            if(!st[j]&&(t==-1||dist[t]>dist[j]))
                t=j;
        }
        //加入到集合S中
        st[t]=true;
        //更新新加入的点，到其余点的距离
        for(j=1;j<=n;j++)
        {
            dist[j]=min(dist[j],dist[t]+g[t][j]);
        }

    }
    //若是仍是无穷大，表明从起点走不到n
    if(dist[n]==0x3f3f3f3f)
        return -1;
    else
        return dist[n];
}

int main()
{
    int i,j;
    cin>>n>>m;
    //初始化权值
    memset(g,0x3f,sizeof(g));
    while(m--)
    {
        int x,y,z;
        cin>>x>>y>>z;
        //由于会有重边存在，只保留最小的便可
        g[x][y]=min(g[x][y],z);
    }
    int ans=Dijkstra();
    cout<<ans;
    return 0;
}

若是是稀疏图，点的个数比较多，1e5个点，用O（n²）就会爆掉，所以咱们引入堆优化版的Dijstra

堆优化版的Dijkstra

原理

将找寻不在S中，且距离最近的点的方法进行优化，采用堆（优先队列的方法），时间复杂度为mlog(n)，就能够解决

思路

对于稀疏图，咱们能够用邻接表结构来进行存储

先上数据，以下。

4 5
1 4 9
4 3 8
1 2 5
2 4 6
1 3 7

第一行两个整数n m。n表示顶点个数（顶点编号为1~n），m表示边的条数。接下来m行表示，每行有3个数x y z，表示顶点x到顶点y的边的权值为z。下图就是一种使用链表来实现邻接表的方法。

 

上面这种实现方法为图中的每个顶点（左边部分）都创建了一个单链表（右边部分）。这样咱们就能够经过遍历每一个顶点的链表，从而获得该顶点全部的边了。使用链表来实现邻接表对于痛恨指针的的朋友来讲，这简直就是噩梦。

这里我将为你们介绍另外一种使用数组来实现的邻接表，这是一种在实际应用中很是容易实现的方法。这种方法为每一个顶点i（i从1~n）也都保存了一个相似“链表”的东西，里面保存的是从顶点i出发的全部的边，具体以下。

首先咱们按照读入的顺序为每一条边进行编号（1~m）。好比第一条边“1 4 9”的编号就是1，“1 3 7”这条边的编号是5。

这里用u、v和w三个数组用来记录每条边的具体信息，即u[i]、v[i]和w[i]表示第i条边是从第u[i]号顶点到v[i]号顶点（u[i]àv[i]），且权值为w[i]。

　　

　　再用一个first数组来存储每一个顶点其中一条边的编号。以便待会咱们来枚举每一个顶点全部的边（你可能会问：存储其中一条边的编号就能够了？不可能吧，每一个顶点都须要存储其全部边的编号才行吧！甭着急，继续往下看）。好比1号顶点有一条边是 “1 4 9”（该条边的编号是1），那么就将first[1]的值设为1。若是某个顶点i没有以该顶点为起始点的边，则将first[i]的值设为-1。如今咱们来看看具体如何操做，初始状态以下。

 

　　咦？上图中怎么多了一个next数组，有什么做用呢？不着急，待会再解释，如今先读入第一条边“1 4 9”。

　　读入第1条边（1 4 9），将这条边的信息存储到u[1]、v[1]和w[1]中。同时为这条边赋予一个编号，由于这条边是最早读入的，存储在u、v和w数组下标为1的单元格中，所以编号就是1。这条边的起始点是1号顶点，所以将first[1]的值设为1。

　　另外这条“编号为1的边”是以1号顶点（即u[1]）为起始点的第一条边，因此要将next[1]的值设为-1。也就是说，若是当前这条“编号为i的边”，是咱们发现的以u[i]为起始点的第一条边，就将next[i]的值设为-1（貌似的这个next数组很神秘啊⊙_⊙）。

 

　　

　　读入第2条边（4 3 8），将这条边的信息存储到u[2]、v[2]和w[2]中，这条边的编号为2。这条边的起始顶点是4号顶点，所以将first[4]的值设为2。另外这条“编号为2的边”是咱们发现以4号顶点为起始点的第一条边，因此将next[2]的值设为-1。

 

　　

　　读入第3条边（1 2 5），将这条边的信息存储到u[3]、v[3]和w[3]中，这条边的编号为3，起始顶点是1号顶点。咱们发现1号顶点已经有一条“编号为1 的边”了，若是此时将first[1]的值设为3，那“编号为1的边”岂不是就丢失了？我有办法，此时只需将next[3]的值设为1便可。如今你知道next数组是用来作什么的吧。next[i]存储的是“编号为i的边”的“前一条边”的编号。（注：next数组的大小由边的数目决定，first数组的大小由顶点的个数来决定）

 

 

　　读入第4条边（2 4 6），将这条边的信息存储到u[4]、v[4]和w[4]中，这条边的编号为4，起始顶点是2号顶点，所以将first[2]的值设为4。另外这条“编号为4的边”是咱们发现以2号顶点为起始点的第一条边，因此将next[4]的值设为-1。

 

 

读入第5条边（1 3 7），将这条边的信息存储到u[5]、v[5]和w[5]中，这条边的编号为5，起始顶点又是1号顶点。此时须要将first[1]的值设为5，并将next[5]的值改成3（编号为5的边的前一条边的编号为3）。

 

 

　　此时，若是咱们想遍历1号顶点的每一条边就很简单了。1号顶点的其中一条边的编号存储在first[1]中。其他的边则能够经过next数组寻找到。请看下图。

 

 　　细心的同窗会发现，此时遍历边某个顶点边的时候的遍历顺序正好与读入时候的顺序相反。由于在为每一个顶点插入边的时候都直接插入“链表”的首部而不是尾部。不过这并不会产生任何问题，这正是这种方法的其妙之处。

实例练习

题目：https://www.acwing.com/problem/content/description/852/

代码

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+10;
typedef long long ll;
ll n,m;
typedef pair<int, int> PII;
int h[maxn],e[maxn],w[maxn],ne[maxn],idx;
int dist[maxn];
bool st[maxn];

void add(int x,int y,int c)
{
    //权值记录
    w[idx]=c;
    //终点边记录
    e[idx]=y;
    //存储编号为idx的边的前一条边的编号
    ne[idx]=h[x];
    //表明以x为起点的边的编号，这个值会发生变化
    h[x]=idx++;
}


ll Dijkstra()
{
    ll i,j;
    memset(dist,0x3f,sizeof(dist));
    dist[1]=0;
    //寻找出非S集合外，距离最小的顶点，并将其加入，更新他到其余边的最短距离
    priority_queue<PII,vector<PII>,greater<PII>> heap;
    //push的集合中：距离，顶点（这里为起点1）
    //这里为啥距离在前，由于会先按第一个值排序，咱们要找出距离最小的边
    heap.push({0,1});
    while(heap.size())
    {
        auto t=heap.top();
        heap.pop();
        //得到顶点和他到起点的距离
        int ver=t.second,distance=t.first;
        //判断是否加入集合里
        if(st[ver])
            continue;
        //加入到集合
        st[ver]=true;
        //遍历他所链接的全部边
        for(int i=h[ver];i!=-1;i=ne[i])
        {
            //跟ver链接的终点j
            int j=e[i];
            //判断j点离原点的距离 > ver点离原点的距离 + ver和j点的距离，哪一个近
            if(dist[j]>dist[ver]+w[i])
            {
                //更新距离
                dist[j]=dist[ver]+w[i];
                //将更新后的距离，和对应的终点j，加入到里面
                heap.push({dist[j],j});
            }
        }
    }
    //若是说原点到终点n的距离仍是无穷，则表明到达不了
    if(dist[n]==0x3f3f3f3f)
        return -1;
    else
        return dist[n];
}

int main()
{
    ll i,j;
    cin>>n>>m;
    //初始化h数组为-1，目的是为ne数组赋值
    memset(h,-1,sizeof(h));
    while(m--)
    {
        int x,y,z;
        cin>>x>>y>>z;
        //加边
        add(x,y,z);
    }
    //堆优化版的Dijkstra
    ll ans=Dijkstra();
    cout<<ans;
    return 0;
}