算法训练 最短路（单源最短路径---Bellman-Ford&&SPFA）

问题描述
给定一个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，保证从任意顶点都能到达其他所有顶点。

本来想学SPFA算法的，就先把这个Bellman-Ford算法学了，就想到了这一题。以前没写出来。
开始想着随便写写，估计也对不了，怎么也得用堆优化的djs或者spfa。就是不用再更新的时候优化了一下，没想到ac了。
vuw数组少一个0才能在Dev c上运行。

Bellman-Ford

#include<stdio.h>
int main()
{
	int i,j,s,x,y,n,m,dis[20005],v[200005],u[200005],w[200005];
	scanf("%d %d",&n,&m);
	for(i=1;i<=m;i++)
		scanf("%d %d %d",&u[i],&v[i],&w[i]);
	for(i=0;i<=n;i++)
		dis[i]=200000;
	dis[1]=0;
	
	for(j=1;j<n;j++){
		int flag=0;
		for(i=1;i<=m;i++)		
			if(dis[v[i]]>dis[u[i]]+w[i]){
				dis[v[i]]=dis[u[i]]+w[i];
				flag=1;
			}
		if(!flag) break;			
	}
		
	for(i=2;i<=n;i++)
		printf("%d\n",dis[i]);
	return 0;	
 } 

head和next数组感觉有点难理解。
这个比bellman慢而且内存用的大，说好了的这个是优化的呢-_-||

SPFA

#include<cstdio> 
#include<queue>
#include<cstring>
using namespace std;
const int maxn=200005;
int n,m,head[maxn],next[maxn],vis[maxn]={0},dis[maxn];
struct node{
	int u,v,wight;
}s[maxn];
void spfa(int x){
	queue<int>q;
	int i,j;
	for(i=0;i<=n;i++)
		dis[i]=1e9;
	dis[1]=0;
	vis[x]=1;
	q.push(x);
	while(!q.empty()){
		int k=q.front();
		q.pop();
		vis[k]=0;
		for(i=head[k];i!=-1;i=next[i]){
			if(dis[s[i].v]>dis[s[i].u]+s[i].wight){
				dis[s[i].v]=dis[s[i].u]+s[i].wight;
				if(!vis[s[i].v]){
					q.push(s[i].v);
					vis[s[i].v]=1;
				}					
			}
		}
	}
}
int main()
{
	int i,j,x,y,z;
	memset(head,-1,sizeof(head));
	memset(next,-1,sizeof(next));
	scanf("%d %d",&n,&m);
	for(i=0;i<m;i++){
		scanf("%d %d %d",&s[i].u,&s[i].v,&s[i].wight);
		next[i]=head[s[i].u];
		head[s[i].u]=i;
	}
	spfa(1);
	for(i=2;i<=n;i++)
		printf("%d\n",dis[i]);
	return 0;
}