## **每日算法**（**day1**）

每日算法（day1）

最短路径——SPFA（单源最短路径算法）算法

定义：我们用数组d记录每个结点的最短路径估计值，用邻接表来存储图G。我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。期望的时间复杂度O(ke)， 其中k为所有顶点进队的平均次数，可以证明k一般小于等于2。
简单理解比如第一次加入点a,求a到其余各顶点的距离，若无法到达则填无穷，第二次加入b点，更新距离表，若小于原来的距离则替换，以此类推直到距离表不再更新
画图举例

step1：加入顶点a

0	24	28	15	∞	∞	∞

step2：加入顶点b

0	24	28	15	30	∞	∞

step3：加入顶点c

0	24	28	15	15	11	∞

step4：加入顶点d

0	24	28	15	15	11	19

step5：加入顶点e
没有出现更短的距离，无需更新

0	24	28	15	15	11	19

step6：加入顶点f

0	24	28	15	13	11	19

step7：加入顶点g

0	17	28	15	13	11	19

例题练习（蓝桥杯）
1 问题描述

问题描述

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

解决源码：

package 算法训练;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
/*
 * spfa算法
 */
public class 最短路 {
	static int leng[];
	public static void main(String[] args) throws IOException {
		// TODO 自动生成的方法存根
		StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		in.nextToken();
		int n=(int)in.nval;in.nextToken();int m=(int)in.nval;
		List<node>list[]=new ArrayList[n];//存储路径
		for(int i=0;i<n;i++)//声明
		{
			list[i]=new ArrayList<>();
		}
	    leng=new int[n];
		boolean jud[]=new boolean[n];//判断是否在队列内
		for(int i=1;i<n;i++) {leng[i]=Integer.MAX_VALUE;}//初始最长均为max
		for(int i=0;i<m;i++)
		{
			in.nextToken();int u=(int)in.nval;
			in.nextToken();int v=(int)in.nval;
			in.nextToken();int l=(int)in.nval;
			list[u-1].add(new node(v-1, l));				
		}
		Queue<Integer>q1=new ArrayDeque<Integer>();
		q1.add(0);//第一个
		while(!q1.isEmpty())
		{
			int x=q1.poll();
			jud[x]=false;
		   for(int i=0;i<list[x].size();i++)//遍历
		{
			   int index=list[x].get(i).x;//x邻居该节点的编号
			   int length=list[x].get(i).leng;//x到这个邻居的距离
				if(leng[index]>leng[x]+length)
				{
					leng[index]=leng[x]+length;
					if(!jud[index])//队列中没有该点
					{q1.add(index);jud[index]=true;}					
				}					
			}
		}
		for(int i=1;i<n;i++)
		{
			out.println(leng[i]);
		}
		out.flush();
	}
	static class node
	{
		int x;
		int leng;
		public node(int x,int leng)
		{
			this.x=x;
			this.leng=leng;
		}
	}
}