java最短路径算法

Ⅰ 有什么无权无向图的最短路径算法比较好，求一个用java实现的

有什么无权无向图的最短路径算法比较好

带权图也分有向和无向两种，基本的算法可以看看书咯。 带权的无向图的最短路径又叫最小生成树，Prim算法和Kruskal算法； 带权的有向图的最短路径算法有迪杰斯特拉算法和佛洛依德算法；

String[]s={"January","February","March","April","May","June","July","August","September","October","November","December"};
System.out.print("请输入数字（1-12）：");
BufferedReaderbr=newBufferedReader(newInputStreamReader(System.in));
Stringstr=br.readLine();
intm=Integer.parseInt(str);
if(m<=0||m>=13)
{

Ⅱ 求最短路径算法

importjava.awt.*;
importjava.util.HashSet;
importjava.util.Random;

classexample2{


privatestaticPoint[]mTestPoints;

//已知平面上N点坐标,求遍历所有点的最短路径.
publicstaticvoidmain(String[]args){

//两点之间的距离d=√(a^2+b^2)其中a=|x1–x2|;b=|y1-y2|
//都是简单的正相关函数,距离最短那么需要a+b最小
//n个点需要求C(n,2)次
//其实java提供了两点之间距离的Api咱们直接使用即可

generateTestPoints();

doubleminDistance=Double.MAX_VALUE;
for(inti=0;i<mTestPoints.length;i++){
//两两计算,数组中每个点只跟后面的点求距离
for(intj=i+1;j<mTestPoints.length;j++){
doubledistance=mTestPoints[i].distance(mTestPoints[j]);
if(distance<minDistance){
minDistance=distance;
}
}
}
//得到结果
System.out.println("最短距离为:"+minDistance);
}

(){

//随机生成10个点的集合,为了去重使用hashSet
Randomrandom=newRandom();
HashSet<Point>mPointSet=newHashSet<>();
for(inti=0;i<10;i++){
booleanadd=mPointSet.add(newPoint(random.nextInt(100),random.nextInt(100)));
if(!add){
--i;
}
}
mTestPoints=mPointSet.toArray(newPoint[10]);
}
}

Ⅲ JAVA求10个景点间各个景点的最短路径 图随便话 距离随便 求代码

最有效，切不复杂的方法使用Breadth First Search (BFS). 基本代码如下（伪代码）。因为BFS不用递归，所以可能会有点难理解。

public Stack findPath(Vertex 起始景点, Vertex 目标景点){
Queue <Vertex> q = new Queue<Vertex>();
s.enqueue(起始景点);
Vertex 当前位置;
while(!s.isEmpty()){
当前位置 = s.dequeue();
if (当前位置 == 目标景点) break;
for (每一个相邻于 当前位置 的景点 Vertex v){
if (!v.visited){
v.parent = 当前位置;
// 不是规定，不过可以节省一点时间
if (v == 目标景点){
current = v;
break;
}
s.enqueue(Vertex v);
v.visited = true;
}
}
}

Stack <Vertex> solution = new Stack <Vertex>();
Vertex parent = current;
while (parent != 起始景点){
solution.push(parent);
parent = current.parent;
}

for (graph中的每一个vertex) vertex.visited = false;

return solution(); // 其实这里建议用一个 Path 的inner class 来装所获得的路线
}

然后再 main 求每两个景点之间的距离即可
public static void main(String[] argv){
PathFinder pf = new PathFinder();

Stack[][] 路径 = new Stack[10][10];

for(int i=0; i<pf.vertices.length; i++){
for(int j=i+1; j<pf.vertices.length; j++){
Stack s = pf.findPath(pf.vertices[i], pf.vertices[j]);
路径[i][j] = s; 路径[j][i] = s; // 假设你的graph是一个undirected graph

}

}

// 这么一来就大功告成了！对于每两个景点n 与 m之间的最短路径就是在 stack[n][m] 中

}

还有一种方法就是用Depth First Search递归式的寻找路径，不过这样比较慢，而且我的代码可能会造成stack overflow

public Stack dfs(Vertex 当前景点，Vertex 目标景点){
if(当前景点 == 目标景点) return;

Stack solution = new Stack();
Stack temp;
for (相邻于 点钱景点 的每一个 Vertex v){
if (!v.visited){
v.visited = true;
temp = dfs(v, 目标景点);
// 抱歉，不记得是stack.size()还是stack.length()

if (solution.size() == 0) solution = temp;
else if(temp.size() < solution.size()) solution = temp;

v.visited = false; 复原

}

}

return solution;

}
然后再在上述的Main中叫dfs...

参考：
http://www.cs.berkeley.e/~jrs/61b/lec/29
http://www.cs.berkeley.e/~jrs/61b/lec/28

Ⅳ JAVA中最短路径算法

给你个算graph上最短路径的比较流行的方法

Algorithm Dijkstra(V, E, cost, s)
T ;
Cost(V[s]) 0
Prev(V[s]) none
for i 0 to length[V] - 1 do
if (i 6= s) then
Cost(V[i]) +1
Prev(V[i]) none
Build heap NotInTree from V
for i 1 to length[V] do
u DeleteMin(NotInTree)
add (u, Prev(u)) to T
for each neighbor v of u do
if (Cost(v) > Cost(u) + cost(u,v)) then
Cost(v) Cost(u) + cost(u,v)
Prev(v) u
return T

Ⅳ 用java语言求最短路径

最短路径就是敲代码。 这个东西行业公认,没有比敲代码学语言更加快的路了。
如果是单纯感兴趣可以买两本书自学 什么thinkinjava之类的，开始肯定看不懂的,谁开始都看不懂,摸索着来,时间长了就理解了。如果有其它语言基础学起来就快多了,因为语言这种东西,除了语法不一样,逻辑都是一样的。
如果是工作需要什么的,可以找个培训啥的。当然前提你有钱。
最后顺带吐个槽,捷径好找的话，程序员这工作就不值钱了。

Ⅵ 求大佬用java帮我实现dijkstra算法，单源最短路径

python">
import heapq
from collections import defaultdict
edges = [["A","B"],["A","D"],["A","E"],["B","C"],["C","E"],["D","E"],["D","C"]]
dist = [10,30,100,50,10,60,20]
res = []
def dijkstra(e,dist,start,end):
‍  hm = defaultdict(list)
‍  for i in range(len(e)):
‍  ‍  hm[e[i][0]].append((e[i][1],dist[i]))
‍  r = {}
‍  r[start] = 0
‍  q = [(0,start,[start])]
‍  while q:
‍  ‍  dis,node,res = heapq.heappop(q)
‍  ‍  if node == end:
‍  ‍  ‍  return dis,res
‍  ‍  for u,v in hm[node]:
‍  ‍  ‍  t = dis+v
‍  ‍  ‍  if u not in r or t < r[u]:
‍  ‍  ‍  ‍  r[u] = t
‍  ‍  ‍  ‍  heapq.heappush(q,(t,u,res+[u]))
‍  return 0,[]
dijkstra(edges,dist,"A","E")