P4779 【模板】单源最短路径 堆优化的dijkstra

P4779 【模板】单源最短路径（标准版）

题目背景

2018 年 7 月 19 日，某位同学在 NOI Day 1 T1 归程 一题里非常熟练地使用了一个广为人知的算法求最短路。

然后呢？

100→60；

Ag→Cu；

最终，他因此没能与理想的大学达成契约。

小 F 衷心祝愿大家不再重蹈覆辙。

题目描述

给定一个 N个点，M 条有向边的带非负权图，请你计算从 S 出发，到每个点的距离。

数据保证你能从 S 出发到任意点。

输入输出格式

输入格式：

 

第一行为三个正整数 N, M, S。 第二行起 M行，每行三个非负整数 u_i, v_i, w_i​，表示从 u_i到 v_i 有一条权值为 w_i 的边。

 

输出格式：

 

输出一行 N个空格分隔的非负整数，表示 SS 到每个点的距离。

 

输入输出样例

输入样例#1： 复制

4 6 1
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4

输出样例#1： 复制

0 2 4 3

说明

样例解释请参考 数据随机的模板题。

1≤N≤100000；

1≤M≤200000；

S=1；

1≤ui​,vi​≤N；

0≤wi​≤109,

0≤∑wi​≤109。

本题数据可能会持续更新，但不会重测，望周知。

2018.09.04 数据更新 from @zzq

 

这个题要用堆优化的dijkstra

#include<bits/stdc++.h>
using namespace std;
#define maxn 100005
#define maxm 200005
#define INF 2147483647
int head[maxn],cnt,n,m,s,vis[maxn],dis[maxn],x,y,z;
struct aa
{
    int u,v,w,next;
}e[maxm];
struct node
{
    int w,now;
    bool operator < (const node&x)const
    {
        return w>x.w;
    }//重载 会让最小的一条路在最上面第一个出来
};
priority_queue<node>q;//优先队列 (STL里面的堆) 
void add(int u,int v,int w)
{
    e[++cnt].u=u;
    e[cnt].v=v;
    e[cnt].w=w;
    e[cnt].next=head[u];//下一条路是head[u] 以u为起点的路 
    head[u]=cnt;
}//初始化 
void dijkstra()
{
    for(int i=1;i<=n;i++)
    dis[i]=INF;
    dis[s]=0;
    q.push((node){0,s});
    while(!q.empty())
    {
        node x=q.top();
        q.pop();
        int u=x.now;
        if(vis[u]) continue;//已经走过的就不要再走了
        vis[u]=1;//标记 已经走过
        for(int i=head[u];i;i=e[i].next)//从这个点开始 往下一条路走 走到不能走 
        {
            int v=e[i].v;
            if(dis[v]>dis[u]+e[i].w)//找最短路 如果这条路比之前的短就取代 
            {
                dis[v]=dis[u]+e[i].w;
                q.push((node){dis[v],v});//入队 
            }
        }
    }
}
int main()
{
    cin>>n>>m>>s;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y>>z;
        add(x,y,z);
    }
    dijkstra();
    for(int i=1;i<=n;i++)
    {
        printf("%d ",dis[i]);
    }
    return 0;
}

vector 优化 

#include<bits/stdc++.h>
using namespace std;
const int inf=0x3f3f3f3f;
const int maxn=2e5+4;
int dis[maxn],book[maxn],n,m;
struct node
{
	int x,d;
	bool operator < (const node&y)const
	{
		return d>y.d;
	}
};
vector<node>G[maxn];
priority_queue<node>q;
void dijkstra(int s)
{
	for(int i=1; i<=n; i++) dis[i]=inf;
	dis[s]=0;
	memset(book,0,sizeof book);
	q.push(node {s,0});
	while(!q.empty())
	{
		node u=q.top();
		q.pop();
		if(book[u.x])continue;
		book[u.x]=1;
		for(int i=0; i<G[u.x].size(); i++)
		{
			node v=G[u.x][i];
			if(dis[v.x]>dis[u.x]+v.d)
			{
				dis[v.x]=dis[u.x]+v.d;
				q.push(node {v.x,dis[v.x]});
			}
		}
	}
}
int main()
{
	int s;
	cin>>n>>m>>s;
	for(int i=1; i<=m; i++)
	{
		int u,v,w;
		cin>>u>>v>>w;
		G[u].push_back(node {v,w});
	}
	dijkstra(s);
	for(int i=1; i<=n; i++)
	{
		printf("%d ",dis[i]);
	}
	return 0;
}