最短路



算法训练 最短路  
时间限制：1.0s   内存限制：256.0MB
      
问题描述
给定一个n个顶点，m条边的有向图（其中某些边权可能为负，但保证没有负环）。请你计算从1号点到其他点的最短路（顶点从1到n编号）。
输入格式
第一行两个整数n, m。
接下来的m行，每行有三个整数u, v, l，表示u到v有一条长度为l的边。
输出格式
共n-1行，第i行表示1号点到i+1号点的最短路。
样例输入
3 3
1 2 -1
2 3 -1
3 1 2
样例输出
-1
-2
数据规模与约定
对于10%的数据，n = 2，m = 2。
对于30%的数据，n <= 5，m <= 10。

对于100%的数据，1 <= n <= 20000，1 <= m <= 200000，-10000 <= l <= 10000，保证从任意顶点都能到达其他所有顶点。

思路：带负权的有向图，不能用Dijkstra算法，因为贪心算法（Dijkstra ）只看到了当前的最小值，有可能在另一条未选择的路的下一步是一个很大的负值，而此时我们已经把他加到树里边，此时就会找到错误答案。SPFA算法适用于不带负权环的，带负权的有向图和不带负权的无向图，因为无向图中若有一条边为负，即相当于这两点形成负权环。算法的核心是广搜，同时用一个数组保存从第一个节点到其他节点的最短路，首先把第一个节点入队列，第一个节点出队列，更新以第一个节点为始点的所有点在最短路数组里的值，若更新成功且该点没在队列中，该点入队。

#include<stdio.h>
#include<iostream>
using namespace std;
#include<queue>

typedef struct 
{
	int v;
	int w;
}Node;

queue<int> q;
vector<Node> g[20000];
int d[20000];
bool f[20000];

void SPFA()
{
	int p, t, i;
	while(!q.empty())
	{
		p = q.front();
		q.pop();
		f[p] = 0;//每次要把标记解除，因为有负值所以可能后面有更小的；
		for(i = 0; i < g[p].size(); i++)
		{
			if(!f[g[p][i].v] && d[g[p][i].v] > d[p] + g[p][i].w)
			{
				f[g[p][i].v] = 1;
				d[g[p][i].v] = d[p] + g[p][i].w;
				q.push(g[p][i].v);
			}
		}
	}
}

int main()
{
	int n, m, a, b ,c,i;
	Node e;
	scanf("%d%d", &n, &m);
	d[1] = 0;
	for(i = 2; i <= n; i++)
	{
		d[i] = 65535;
	}
	for(i = 0; i < m; i++)
	{
		scanf("%d%d%d", &a, &b, &c);
		e.v = b;
		e.w = c;
		g[a].push_back(e);
	}
	q.push(1);
	SPFA();
	for(i = 2; i <= n;i++)
	{
		printf("%d\n", d[i]);
	}
	return 0;
}