我遇到了将Dijkstras算法的伪代码转换为实际代码的问题。我被给予和邻接列表，如＆＃34;位置 - 相邻位置 - 到位置的距离，＆＃34;一个节点的示例：AAA AAC 180 AAD 242 AAH 40。 我的任务是读取如上所述组织为邻接列表的文件，并计算从一个节点到另一个节点的最短路径。 这是Dijkstra伪代码：
void dijkstra( Vertex s )
{
for each Vertex v
{
v.dist = INFINITY;
v.known = false;
}
s.dist = 0;
while( there is an unknown distance vertex )
{
Vertex v = smallest unknown distance vertex;
v.known = true;
for each Vertex w adjacent to v
if( !w.known )
{
DistType cvw = cost of edge from v to w;
if( v.dist + cvw < w.dist )
{
// Update w
decrease( w.dist to v.dist + cvw );
w.path = v;
}
}
}
}
对于与＆＃34;相邻的每个Vertex w，对于线＆＃34;最麻烦的是 这是我的非工作代码：
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
public class Dijkstra {
public static boolean isInteger(String s) {
return isInteger(s, 10);
}
public static boolean isInteger(String s, int radix) {
if (s.isEmpty())
return false;
for (int i = 0; i < s.length(); i++) {
if (i == 0 && s.charAt(i) == '-') {
if (s.length() == 1)
return false;
else
continue;
}
if (Character.digit(s.charAt(i), radix) < 0)
return false;
}
return true;
}
public static void dijkstra(Vertex[] a, Vertex s, int lineCount) {
int i = 0;
while (i < (lineCount)) // each Vertex v
{
a[i].dist = Integer.MAX_VALUE;
a[i].known = false;
i++;
}
s.dist = 0;
int min = Integer.MAX_VALUE; //
while (!(a[0].known == true && a[1].known == true && a[2].known == true && a[3].known == true
&& a[4].known == true && a[5].known == true && a[6].known == true && a[7].known == true
&& a[8].known == true && a[9].known == true && a[10].known == true && a[11].known == true
&& a[12].known == true)) {
System.out.println("here");
for (int b = 0; b < lineCount; b++) {
if (a[b].dist < min && a[b].known == false) {
min = a[b].dist;
}
}
int c = 0;
while (c < lineCount) {
if (a[c].dist == min && a[c].known == false) {
break;
}
c++;
}
System.out.println(min);
a[c].known = true;
int adjSize = a[c].adj.size();
int current = 0;
System.out.println(adjSize);
while (current < adjSize - 1) {
String currentAdjacent = (String) a[c].adj.get(current);
int p = 0;
while (p < lineCount) {
if (a[p].name.equals(currentAdjacent)) {
if (!a[p].known) {
String cvwString = (String) a[c].distance.get(current);
int cvw = Integer.parseInt(cvwString);
System.out.println(" This is cvw" + cvw);
System.out.println("Here2");
if (a[c].dist + cvw < a[p].dist) {
a[p].dist = a[c].dist + cvw;
a[p].path = a[c];
}
}
}
p++;
}
current++;
}
}
}
public static class Vertex {
public List adj; // Adjacency list
public List distance;
public boolean known;
public int dist; // DistType is probably int
public Vertex path;
public String name;
// Other fields and methods as needed
}
public static void printPath(Vertex v) {
if (v.path != null) {
printPath(v.path);
System.out.print(" to ");
}
System.out.print(v);
}
public static void main(String[] args) throws IOException {
int lineCounter = 0;
BufferedReader br = new BufferedReader(new FileReader("airport.txt"));
try {
StringBuilder sb = new StringBuilder();
String line = br.readLine();
while (line != null) {
sb.append(line);
sb.append(System.lineSeparator());
line = br.readLine();
lineCounter = lineCounter + 1;
}
Vertex[] arr = new Vertex[lineCounter];
for (int i = 0; i < lineCounter; i++) {
arr[i] = new Vertex();
arr[i].adj = new LinkedList<String>();
arr[i].distance = new LinkedList<Integer>();
}
;
//
int arrayCounter = 0;
String everything = sb.toString();
String[] lines = everything.split("\\s*\\r?\\n\\s*");
for (String line1 : lines) {
arr[arrayCounter] = new Vertex();
arr[arrayCounter].adj = new LinkedList<String>();
arr[arrayCounter].distance = new LinkedList<Integer>();
String[] result = line1.split("\\s+");
for (int x = 0; x < result.length; x++) {
if (x == 0) {
arr[arrayCounter].name = result[0];
continue;
} else if (isInteger(result[x])) {
arr[arrayCounter].distance.add(result[x]);
continue;
} else {
arr[arrayCounter].adj.add(result[x]);
continue;
}
}
arrayCounter++;
}
for (int i = 0; i < 12; i++) {
System.out.println(arr[i].name);
}
System.out.println(lineCounter);
dijkstra(arr, arr[3], lineCounter - 1);
printPath(arr[11]);
} finally {
br.close();
}
}
}
使用我的顶点类，我首先使用一系列while循环，遍历存储在链表中的邻接字符串，同时比较查看哪个顶点等效于邻接列表字符串。是否有更好的方法来编码＆＃34;对于与v＆＃34相邻的每个Vertex w？使用我的Vertex类？对于凌乱的代码以及我可能犯下的任何其他风格的罪行，我们要道歉。谢谢！
答案 0 :(得分：1)
要解决这个问题，您需要一堆“节点”对象，存储在HashMap中，键入源位置。
在节点中，您需要一组对相邻“节点”对象的引用（或者至少是它们的“键”，因此您可以针对它编写逻辑。“节点”还需要知道它的位置和距离“相邻的“节点。想想Lundon地下管地图 - 每个站点至少连接一个其他站点。通常是两个或更多。因此，管站的相邻节点是您可以从该站点到达的下一站。
一旦有了这个数据结构，就可以使用递归例程迭代每个单独的节点。然后它应遍历每个子节点（也称为相邻节点），并通过将此数据存储在HashMap中并使用当前累积距离同时递归（或“行走”图形）来跟踪从初始（源）节点到当前节点的距离“）。这种跟踪信息应该是递归时方法签名的一部分。你还需要跟踪你在递归时所采用的当前路径，以避免循环循环（最终会讽刺地导致StackOverflowError）。你可以通过使用HashSet来执行此操作。此Set应跟踪源和当前节点的位置作为输入键。如果您在递归期间看到此信息，那么您已经看过它，因此不要继续处理。
我不打算为你编写解决方案，因为我怀疑你在通过理解答案的过程中提出更具体的问题，这很可能在其他地方得到解答。