# hihocoder #1093 : 最短路径·三：SPFA算法

标签（空格分隔）： hihocoder

1093 : 最短路径·三：SPFA算法

　　对于稀疏图，边的数目远小于N^2(其中，N指顶点数）。因此邻接矩阵中会有大量的“表示”此边不存在的元素，不仅浪费了空间，也降低了效率。这里参考《算法竞赛入门经典》中第11章用矩阵来表示邻接表（Adjacency List）。算法实现参照其11.2.4节。这种表示法，每个结点i都有一个链表，里面保存着从i出发的所有边。对于无向图来说，每条边会在邻接表中出现两次。

　　这里用数组实现了链表：首先给每条边编号，然后用first[u]保存结点u的第一条边的编号，next[e]表示编号为e的边的“下一条边”的编号。

　　SPFA（Shortest Path Faster Algorithm）是Bellman-Ford算法的一种队列实现，减少了不必要的计算。算法大致流程是用一个队列来进行维护。初始时将起始点加入队列，每次从队列中取出一个元素，并与所有与它相邻的点进行松弛，若某个相邻的点松弛成功，则将其入队。直到队列为空时结束算法。（参考SPFA算法）

题目：

Time Limit:10000ms

Case Time Limit:1000ms

Memory Limit:256MB

描述

万圣节的晚上，小Hi和小Ho在吃过晚饭之后，来到了一个巨大的鬼屋！

鬼屋中一共有N个地点，分别编号为1..N，这N个地点之间互相有一些道路连通，两个地点之间可能有多条道路连通，但是并不存在一条两端都是同一个地点的道路。

不过这个鬼屋虽然很大，但是其中的道路并不算多，所以小Hi还是希望能够知道从入口到出口的最短距离是多少？

提示：Super Programming Festival Algorithm。

输入

每个测试点（输入文件）有且仅有一组测试数据。

在一组测试数据中：

第1行为4个整数N、M、S、T，分别表示鬼屋中地点的个数和道路的条数，入口（也是一个地点）的编号，出口（同样也是一个地点）的编号。

接下来的M行，每行描述一条道路：其中的第i行为三个整数u_i, v_i, length_i，表明在编号为u_i的地点和编号为v_i的地点之间有一条长度为length_i的道路。

对于100%的数据，满足N<=10^5，M<=10^6, 1 <= length_i <= 10^3, 1 <= S, T <= N, 且S不等于T。

对于100%的数据，满足小Hi和小Ho总是有办法从入口通过地图上标注出来的道路到达出口。

输出

对于每组测试数据，输出一个整数Ans，表示那么小Hi和小Ho为了走出鬼屋至少要走的路程。

Sample Input

5 10 3 5

1 2 997

2 3 505

3 4 118

4 5 54

3 5 480

3 4 796

5 2 794

2 5 146

5 4 604

2 5 63

Sample Output

172

import java.util.LinkedList;
import java.util.Scanner;

public class Main {
final static int MAXN = 100005;
final static int MAXM = 1000005;
final static int INF = 1000000005;

public static void main(String[] args) {
Scanner sin = new Scanner(System.in);
int N = sin.nextInt();
int M = sin.nextInt();
int st = sin.nextInt();
int ed = sin.nextInt();
sin.nextLine();

int[] first = new int[MAXN];
int[] ustpoint = new int[MAXM];
int[] venpoint = new int[MAXM];
int[] wlen = new int[MAXM];
int[] next = new int[MAXM];

for (int i = 0; i < N; i++) {
first[i] = -1;
}

int i = 0;
int cnt = 0;
while (i++ < M) {
int ct1 = sin.nextInt();
int ct2 = sin.nextInt();
int ct3 = sin.nextInt();
sin.nextLine();
// 无向图，每条边出现两次
ustpoint[cnt] = ct1;
venpoint[cnt] = ct2;
wlen[cnt] = ct3;
next[cnt] = first[ustpoint[cnt]];
first[ustpoint[cnt]] = cnt;
++cnt;
ustpoint[cnt] = ct2;
venpoint[cnt] = ct1;
wlen[cnt] = ct3;
next[cnt] = first[ustpoint[cnt]];
first[ustpoint[cnt]] = cnt;
++cnt;
}

LinkedList<Integer> queue = new LinkedList<Integer>();
queue.add(st);
boolean[] inq = new boolean[MAXN];
for(int j = 1; j < MAXN; j++) {
inq[j] = false;
}
int[] dis = new int[MAXN];
for(int j = 1; j < MAXN; j++) {
dis[j] = INF;
}
dis[st] = 0;

while (!queue.isEmpty()) {
int qstart = queue.getFirst();
queue.removeFirst();
inq[qstart] = false;

for (int e = first[qstart]; e != -1; e = next[e]) {
if (dis[venpoint[e]] > dis[qstart] + wlen[e]) {
dis[venpoint[e]] = dis[qstart] + wlen[e];
if (!inq[venpoint[e]]) {
queue.addLast(venpoint[e]);
inq[venpoint[e]] = true;
}
}
}
}
System.out.println(dis[ed]);
}
}

C++解法：http://www.mamicode.com/info-detail-400547.html

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#define INF 0x3f3f3f3f
using namespace std;

const int MAX = 100005;
int dis[MAX], vis[MAX] ,head[MAX];
int n, m, s, t, cnt;

struct edge
{
int v, w, next;
}edge[1000005];

void addedge(int u, int v, int w)
{
edge[cnt].v = v;
edge[cnt].w = w;
edge[cnt].next = head[u];
head[u] = cnt++;
}

void spfa(int s)
{
int pos, v;
queue<int> q;
q.push(s);
dis[s] = 0; vis[s] = 1;
while(!q.empty())
{
pos = q.front(); q.pop();
vis[pos] = 0;
for(int i = head[pos]; i != -1; i = edge[i].next)
{
v = edge[i].v;
if(dis[pos] + edge[i].w < dis[v])
{
dis[v] = dis[pos] + edge[i].w;
if(!vis[v])
{
vis[v] = 1;
q.push(v);
}
}
}
}
}

int main()
{
while(scanf("%d %d %d %d", &n, &m, &s, &t) != EOF)
{
cnt = 0;
memset(head, -1, sizeof(head));
memset(vis, 0, sizeof(vis));
memset(dis, 0x37, sizeof(dis));
while(m--)
{
int x, y, w;
scanf("%d %d %d", &x, &y, &w);
addedge(x, y, w);
addedge(y, x, w);
}
spfa(s);
printf("%d\n", dis[t]);
}
return 0;
}