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

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

## 题目背景

2018 年 7 月 19 日，某位同学在 [NOI Day 1 T1 归程](https://www.luogu.org/problemnew/show/P4768) 一题里非常熟练地使用了一个广为人知的算法求最短路。

然后呢？

$100 \rightarrow 60$；

$\text{Ag} \rightarrow \text{Cu}$；

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

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

## 题目描述

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

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

## 输入格式

第一行为三个正整数 $n, m, s$。
第二行起 $m$ 行，每行三个非负整数 $u_i, v_i, w_i$，表示从 $u_i$ 到 $v_i$ 有一条权值为 $w_i$ 的有向边。

## 输出格式

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

## 样例 #1

### 样例输入 #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
```

## 提示

样例解释请参考 [数据随机的模板题](https://www.luogu.org/problemnew/show/P3371)。

$1 \leq n \leq 10^5$；

$1 \leq m \leq 2\times 10^5$；

$s = 1$；

$1 \leq u_i, v_i\leq n$；

$0 \leq w_i \leq 10 ^ 9$,

$0 \leq \sum w_i \leq 10 ^ 9$。

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

2018.09.04 数据更新 from @zzq

1.这个问题用dijkstra算法即可，要使用堆优化的dijkstra算法，否则会时间超限。

2.刚开始我是想自己手写一个堆，模拟优先队列，然而修修改改还是只是AC了俩个点 ，没办法去学了C++里面的STL里的优先队列。

3.继而就简单多了（代码少了将近一大半）

4.堆优化的dijkstra算法也是非常简单，核心思想是一样的，先松弛，再找最近的那一个点，继续松弛循环下去。用堆来实现就是把新更新的距离权值入队，然后在优先队列里面会自动在首元素是最小值了。我们只需要判断堆顶元素是否访问过即可，如果访问过了，就弹出堆顶元素，继续找就可以。

    while( !q.empty() )//如果队列不为空，就需要继续访问
    {
        tmp = q.top();//访问堆顶元素
        q.pop();//弹出队头
        x = tmp.pos, w = tmp.w;
        if( book[x] )
            continue;//如果该点已经纳入最短路径，需要跳过
        book[x] = 1;//从该点开始松弛
        for(i = head[x]; i; i = e[i].next )//链式前向星
        {
            y = e[i].to;
            if( dis[y] > dis[x] + e[i].w )
            {
                dis[y] = dis[x] + e[i].w;
                if( !book[y] )
                {
                    q.push( ( node ){dis[y], y} );//插入元素并且重新排序
                }
            }
        }
    }

完整C++代码如下：

#include<iostream>
#include<bits/stdc++.h>
#include<cstdio>
#include<algorithm>

using namespace std;

const int N = 100010, M = 500010;
const int INF=1000000000;
struct edges
{
    int to;
	int w;
	int next;
}e[M];
int head[N], dis[N];
bool book[N];
int n, m, s;
struct node
{
    int w;
    int pos;
    bool operator <( const node &x )const
    {
        return x.w <w;
    }
};
priority_queue<node> q;//建立堆
void dijk()
{
	int i,y,x,w;
	node tmp;
    dis[s] = 0;
    q.push( ( node ){0, s} );//放入该节点，也就是入队
    while( !q.empty() )//如果队列不为空，就需要继续访问
    {
        tmp = q.top();//访问堆顶元素
        q.pop();//弹出队头
        x = tmp.pos, w = tmp.w;
        if( book[x] )
            continue;//如果该点已经纳入最短路径，需要跳过
        book[x] = 1;//从该点开始松弛
        for(i = head[x]; i; i = e[i].next )//链式前向星
        {
            y = e[i].to;
            if( dis[y] > dis[x] + e[i].w )
            {
                dis[y] = dis[x] + e[i].w;
                if( !book[y] )
                {
                    q.push( ( node ){dis[y], y} );//插入元素并且重新排序
                }
            }
        }
    }
    for( i = 1; i <= n; i++ )
        printf( "%d ", dis[i] );
}
int main()
{
	int i,u,v,w;
    scanf( "%d%d%d", &n, &m, &s );
    for(i = 1; i <= n; i++) 
		dis[i] =INF;
    for(i = 1; i <= m; i++)
    {
        scanf( "%d%d%d", &u, &v, &w );
        e[i].to=v;
		e[i].w=w;
		e[i].next=head[u];
        head[u]=i;
    }
    dijk();
    return 0;
}