P3371 【模板】单源最短路径（弱化版）（dijkstra模板题）

Goblin的ac路

已于 2022-11-11 23:06:08 修改

阅读量912

点赞数 1

分类专栏：算法与数据结构洛谷文章标签： c++

于 2022-04-01 19:40:55 首次发布

本文链接：https://blog.csdn.net/weixin_53439401/article/details/123905134

版权

算法与数据结构同时被 2 个专栏收录

127 篇文章 3 订阅

订阅专栏

洛谷

20 篇文章 0 订阅

订阅专栏

题目背景

本题测试数据为随机数据，在考试中可能会出现构造数据让SPFA不通过，如有需要请移步 P4779。

题目描述

如题，给出一个有向图，请输出从某一点出发到所有点的最短路径长度。

输入格式

第一行包含三个整数 n,m,s，分别表示点的个数、有向边的个数、出发点的编号。

接下来 m 行每行包含三个整数 u,v,w，表示一条 u→v 的，长度为 w 的边。

输出格式

输出一行 n 个整数，第 i 个表示 s 到第 i 个点的最短路径，若不能到达则输出 −1。

输入输出样例

输入 #1

输出 #1

0 2 4 3

说明/提示

【数据范围】
对于 20% 的数据：1≤n≤5，1≤m≤10000；
对于 40% 的数据：1≤n≤100，1≤m≤10000；
对于 70% 的数据：1≤n≤1000，1≤m≤100000；
对于 100% 的数据：1≤n≤10000，1≤m≤5×100000，1≤u,v≤n，w≥0，∑w<2^31，保证数据随机。

对于真正 100%的数据，请移步 P4779。请注意，该题与本题数据范围略有不同。

样例说明：

图片1到3和1到4的文字位置调换

结构体使用优先队列时需要重载优先性

bool operator<(Node a, Node b){//返回true时，说明a的优先级低于b
//x值较大的Node优先级低（x小的Node排在队前）
//x相等时，y大的优先级低（y小的Node排在队前）
   if( a.x== b.x ) return a.y> b.y;
return a.x> b.x;
}

bool operator>( Node a, Node b ){//返回true，a的优先级大于b
//x大的排在队前部；x相同时，y大的排在队前部
if( a.x== b.x ) return a.y> b.y;
return a.x> b.x;
}

总的来说使用大顶堆用第一个，使用小顶堆用第二个

参考结构体&优先队列自定义排序_guozuofeng的博客-CSDN博客_优先队列结构体排序

链式前向星

参考这两个文章，看完必会链式前向星--最通俗易懂的讲解_sugarbliss的博客-CSDN博客_链式前向星

深度理解链式前向星_ACdreamers的博客-CSDN博客_链式前向星

Code

不使用堆优化、不使用链式前向星

//不适用堆优化、不使用链式前向星
#include<bits/stdc++.h>
using namespace std;
const int inf=pow(2,31)-1;
int n , m , s ;
struct edge
{
    int  v , w;
};
vector<edge> e[500005];
int  dis[100005] , pre[100005] ;
bool vis[100005] ;
void init()
{
    for(int i=0;i<=n;i++)
        dis[i]=inf,vis[i]=false;
    dis[s]=0;
}
void dijkstra(){
    for(int i=1;i<=n;i++){
        int min_dis=inf , min_i=s;
        for(int j=1;j<=n;j++){
            if(!vis[j] && min_dis>dis[j]){
                min_dis=dis[j];
                min_i=j;
            }
        }
        vis[min_i]=true; 
        for(int j=0;j<e[min_i].size();j++){
            //if(!vis[j]){
            int y = e[min_i][j].v;
            int d = e[min_i][j].w;
            dis[y] = min(dis[y], dis[min_i] + d); //松弛操作
        }
    }
}

int main()
{
    cin>>n>>m>>s;
    init();
    for(int i=0;i<m;i++)
    {
        int u , v , w ;
        cin>>u>>v>>w;
        e[u].push_back({v,w});
    }
    dijkstra();
    for(int i=1;i<=n;i++)
        cout<<dis[i]<<" ";
    return 0;
}

使用堆优化，不使用链式前向星

//使用堆优化，不使用链式前向星
#include<bits/stdc++.h>
using namespace std;
const int inf=pow(2,31)-1;
int n , m , s ;
struct edge
{
    int  v , w;
    edge(int a , int b){v=a;w=b;}
    bool operator <( const edge & a) const
    {
        return w > a.w;
    }
};
vector<edge> e[500005];
int  dis[100005] , pre[100005] ;
bool vis[100005] ;
void init()
{
    for(int i=0;i<=n;i++)
        dis[i]=inf,vis[i]=false;
    dis[s]=0;
}
void dijkstra(){
    priority_queue<edge> q;//声明优先队列：每次从队列中取出的是具有最高优先权的元素。
	//greater实现小顶堆//less 实现大顶堆（默认为大顶堆）
	q.push(edge(s,0));//将他本身先推进优先队列
    while(!q.empty()){//当队列空时已将所有边加入队列并推出
        edge p = q.top();
        int x=p.v;
        q.pop();
        if(vis[x]) continue;
        vis[x] = true;
        for(int i=0;i<e[x].size();i++){//每一条与x相邻的边都要更新
            if(vis[e[x][i].v]) continue ;
            int y = e[x][i].v;
            int d = e[x][i].w;
            if(dis[y]>dis[x]+d)
            dis[y]=dis[x]+d;
            q.push(edge(y,dis[y]));//把每一个更新的长度加进队列
        }
    }
}


int main()
{
    cin>>n>>m>>s;
    init();
    for(int i=0;i<m;i++)
    {
        int u , v , w ;
        cin>>u>>v>>w;
        e[u].push_back({v,w});
    }
    dijkstra();
    for(int i=1;i<=n;i++)
        cout<<dis[i]<<" ";
    return 0;
}

使用堆优化，使用链式前向星记录边

//使用优先队列（堆）优化，使用链式前向星存边
//使用优先队列（堆）优化，使用链式前向星存边
#include<bits/stdc++.h>
using namespace std;
const int inf=pow(2,31)-1;
int n , m , s , cnt ;
int head[100005] ;
struct node    //放进队列的结点
{
    int  v , w ;  //v下一个结点  //w
    node(int a , int b){v=a;w=b;}
    bool operator <( const node & a) const   
    //重载结构体的比较方法，使得优先队列能够比较元素大小
    //返回true时，说明前面的优先级较低
    {
        return w > a.w;     
    }
};
struct edge   //用于链式前向星
{
    int v , w , next ;
}e[500010]; 
int  dis[100005] ;//距离数组 ，记录，每个结点到起始点最短距离  
bool vis[100005] ;//记录结点是否已得到最短距
void init()   //初始化变量
{
    for(int i=0;i<=n;i++)
        dis[i]=inf,vis[i]=false;   
    dis[s]=0;   //起始点的距离为0
    memset(head,-1,sizeof head );  //将head数组初始化为-1
}
void addedge(int u , int v , int w )  //链式前向星添加边   //使用时从后往前遍历
{
    e[cnt].v=v;  //下一个结点
    e[cnt].w=w;  //到下一个结点的权值
    e[cnt].next=head[u]; //next为上一条边
    head[u]=cnt++;  //记录输入的每个节点的最后一条边的下标
}
void dijkstra(){
    priority_queue<node> q;//声明优先队列：每次从队列中取出的是具有最高优先权的元素。
	//greater实现小顶堆//less 实现大顶堆（默认为大顶堆）
	q.push(node(s,dis[s]));//将他本身先推进优先队列
    while(!q.empty()){//当队列空时已将所有边加入队列并推出
        node p = q.top();
        q.pop();
        if(vis[p.v]) continue;   //如果该点已经有起始点开始的最短路则下一循环
        vis[p.v] = true;
        for(int i=head[p.v];i!=-1;i=e[i].next){//每一条与x相邻的边都要更新 
                                                //i等于-1时则已没有上一条边
            edge temp = e[i];
            if(vis[temp.v]) continue ;//如果该点已经有起始点开始的最短路则下一循环
            dis[temp.v]=min(dis[temp.v],temp.w+dis[p.v]); //松弛操作    
            //比较难理解，不知道怎么说，仔细看代码慢慢理解吧哈哈哈
            q.push(node(temp.v,dis[temp.v]));//把每一个更新的长度加进队列
        }
    }
}
 
int main()
{
    cin>>n>>m>>s;
    init();
    for(int i=0;i<m;i++)
    {
        int u , v , w ;
        cin>>u>>v>>w;
        addedge(u,v,w);
    }
    dijkstra();
    for(int i=1;i<=n;i++)
        cout<<dis[i]<<" ";
    return 0;
}

学习参考dijkstra模板（易理解）_Feed_Sheep的博客-CSDN博客

Dijkstra模板_Mr·Charles的博客-CSDN博客_dijkstra模板