学习笔记12||搜索与图论||最短路_堆优化的dijkstra-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_45711276/article/details/106248840

常见最短路问题：
1、单源最短路
求一个点到其他所有点的最短距离
(1) 所有边全都是正数

朴素Dijkstra O(n²)
堆优化版的Dilkstra算法O(mlogn)
(2)存在负权边
Bellman-Ford o(mn)
SPFA 一般O(m)
2、多源汇最短路
源即起点，汇点即终点
起点与终点都是不确定的
Floyd算法O(n³)
最短路的核心就是建图，把问题抽象出来。

最短路问题的难点在建图的过程。图论在笔试面试中常考

朴素Dijkstra

1、初始化：dis[1]=0,dis[i}=+无穷
2、确定每个点到起点的最短路
si 当前已经确定最短距离的点
for(i:0~n)
t 不在s中的距离最近的点
把t加入s中相当于最近的点就是下一个确定距离的点
用t来更新其他点的距离
稠密图用邻接矩阵，稀疏图用邻接表。

memset()初始化函数，作用是将某一块内存中的内容全部设置为指定的值，这个函数通常为新申请的内存做初始化工作。例：memset(g,0x3f,sizeof g);

例849 朴素Dijkstra算法

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=510;

int g[N][N];    //为稠密阵所以用邻接矩阵存储
int dist[N];    //用于记录每一个点距离第一个点的距离
bool st[N];     //用于记录该点的最短距离是否已经确定

int n,m;

int Dijkstra()
{
    memset(dist, 0x3f,sizeof dist);     //初始化距离  0x3f代表无限大

    dist[1]=0;  //第一个点到自身的距离为0

    for(int i=0;i<n;i++)      //有n个点所以要进行n次 迭代
    {
        int t=-1;       //t存储当前访问的点

        for(int j=1;j<=n;j++)   //这里的j代表的是从1号点开始
            if(!st[j]&&(t==-1||dist[t]>dist[j]))     
                t=j;

        st[t]=true;   

        for(int j=1;j<=n;j++)           //依次更新每个点所到相邻的点路径值
            dist[j]=min(dist[j],dist[t]+g[t][j]);
    }

    if(dist[n]==0x3f3f3f3f) return -1;  //如果第n个点路径为无穷大即不存在最低路径
    return dist[n];
}
int main()
{
    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);     //如果发生重边的情况则保留最短的一条边
    }

    cout<<Dijkstra()<<endl;
    return 0;
}

朴素Dijkstra算法最核心的就是两步：1、找到没确定最小距离的点，将最小距离的这个加入到s中，表示已经确定最小距离。
2、用这个点，去更新其他的点的距离，更新完成之后在重复进行第一步。直到n个点都确定最小距离。

堆优化Dijkstra

在朴素版中，寻找距离最近的点的时间复杂度较高，为n² ,但是要是采取堆进行存储的话，取最小值的不需要遍历，时间的复杂度为1，更新m条边的时间复杂度变成logn。
堆的实现的话，可以用数组来自己写，也可以用优先队列直接写。
优先队列不支持修改任意元素，导致有可能会存在冗余。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>

using namespace std;
typedef pair<int,int> PII;

const int N=100010;
int h[N],e[N],ne[N],idx,w[N];
int dist[N];
bool st[N];
int n,m;

void add(int a,int b,int c){
    e[idx]=b;
    w[idx]=c;
    ne[idx]=h[a];
    h[a]=idx++;
}
int dijktra(){
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    priority_queue<PII,vector<PII>,greater<PII>>heap;
    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]){
            int j=e[i];
            if(dist[j]>distance+w[i])
             {
                 dist[j]=distance+w[i];
                 heap.push({dist[j],j});
             }
        }
    }
    if(dist[n]==0x3f3f3f3f)return -1;
    return dist[n];

}

int main(){
    memset(h,-1,sizeof h);
    cin>>n>>m;
    while(m--){
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    cout<<dijktra()<<endl;
    return 0;
}

Bellman-Ford算法

for(n)
for 循环所有边a,b,w (a,b是两个点，w是长度)
存在负边 dist[b]=min(dist[b],dist[a]+w)
在循环结束之后，所有的都满足 dist[b]<dist[a]+w;
有负权路存在的话，最短路不一定存在
时间复杂度O(mn);

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N=510,M=10010;

int n,m,k;
int dist[N],backup[N];

struct  Edge{
    int a,b,w;
}edges[M];

int bellman_ford(){
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i=0;i<k;i++){
        memcpy(backup,dist,sizeof dist);
        for(int j=0;j<m;j++){
            int a=edges[j].a,b=edges[j].b,w=edges[j].w;
            dist[b]=min(dist[b],dist[a]+w);
        }
    }
    if(dist[n]>0x3f3f3f/2) return -1;
    return dist[n];
}

int main(){
    scanf("%d%d%d",&n,&m,&k);
    for(int i=0;i<m;i++){
        int a,b,w;
        scanf("%d%d%d",&a,&b,&w);
         edges[i]={a,b,w};
    }
    int t=bellman_ford();
    if(t==-1) puts("impossible");
    else printf("%d\n",t);
    return 0;
   
}

SPFA

对bellman_ford算法进行优化；
对dist[b]=min(dist[b],dist[a]+w)进行优化
更新过谁再拿谁来更新别人。只有在自己更新变小之后才有可能让其他人变小。用队列，在队列中存放的是待更新的点

#include<cstring>
#include<algorithm>
#include<cstring>
#include<queue>
#include<iostream>

using namespace std;
const int N=100010;

int n,m;
int h[N],w[N],e[N],ne[N],idx;
int dist[N];
bool st[N];

void add(int a,int b,int c){
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
int spfa()
{
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    queue<int> q;
    q.push(1);
    st[1]=true;
    
    while(q.size()){
        int t=q.front();
        q.pop();
         st[t]=false;
         for(int i=h[t];i!=-1;i=ne[i]){
             int j=e[i];
             if(dist[j]>dist[t]+w[i])
             {
                 dist[j]=dist[t]+w[i];
                 if(!st[j]){
                     q.push(j);
                     st[j]=true;
                 }
             }
         }
    }
    if(dist[n]>0x3f3f3f/2) return -1;
    return dist[n];
}

int main(){
    scanf("%d%d",&n,&m);
    memset(h,-1,sizeof h);
    while(m--){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
        
    }
    int t=spfa();
    if(t==-1) puts("impossible");
    else printf("%d\n",t);
    return 0;
}