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")