java计算最长路径spfa,蓝桥杯最短路(java过)&&spfa单源最短路算法

spfa

百度百科上spfa的思路为：动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。

俗人的解释:用普通队列存点，每次抛出的点如果更新了周围邻居的距离并且这个点不在队列中，那么这个邻居点被更新了的就加入队列尾。一直到所有操作都不会改变邻居的距离，当队列为空时，当然，这可能要特殊处理有没有成负环(一般不会)。

百科上两个优化策略：

SPFA算法有两个优化策略SLF和LLL——SLF：Small Label First 策略，设要加入的节点是j，队首元素为i，若dist(j)x则将i插入到队尾，查找下一元素，直到找到某一i使得dist(i)<=x，则将i出队进行松弛操作。SLF 和 LLF 在随机数据上表现优秀，但是在正权图上最坏情况为 O(VE)，在负权图上最坏情况为达到指数级复杂度。

蓝桥杯 最短路

这题用dijkstra过不了，只能用spfa.裸的spfa。

算法训练 最短路

时间限制：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，保证从任意顶点都能到达其他所有顶点。

JAVA代码：

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;

Listlist[]=new ArrayList[n];//存储路径

for(int i=0;i

{

list[i]=new ArrayList<>();

}

leng=new int[n];

boolean jud[]=new boolean[n];//判断是否在队列内

for(int i=1;i

for(int i=0;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));

}

Queueq1=new ArrayDeque();

q1.add(0);//第一个

while(!q1.isEmpty())

{

int x=q1.poll();

jud[x]=false;

for(int i=0;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

{

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;

}

}

}

运行结果为

本文分享 CSDN - Big sai。

如有侵权，请联系 support@oschina.cn 删除。

本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。