统一成本搜索

Question

我很难弄清楚如何解决这个问题。我有一个 .txt 文件，其中包含 2 个城市，它们之间的距离在每行上用空格分隔。我的目标是以 2 个城市为参数，并找到最短路径。我创建了 3 个类。 Main、Node 和 Road（边）。

public class Node {
    public Node parent;
    public final String cityName;
    public double pathCost;
    public Road[] neighbors;

    public Node(String x){
        cityName = x;
    }

    public String myCity(){
        return cityName;
    }
}

和

public class Road {
    public final double distance;
    public final Node destination;

    public Road(Node x, double cost){
        distance = cost;
        destination = x;
    }
}

我想知道如何存储节点和边。以下代码是我的尝试。好像可以，但是感觉效率不是很高。

public void initNodes(){
    ArrayList<String> cities = new ArrayList<String>();
    for(String line : myLines){
        String[] split = line.split("\\s+");
        if(!cities.contains(split[0]))
        {
            cities.add(split[0]);
            Node n1 = new Node(split[0]);
            myNodes.add(n1);
        }
        if(!cities.contains(split[1]))
        {
            cities.add(split[1]);
            Node n = new Node(split[1]);
            myNodes.add(n);
        }
    }       
}

在第一次调用该方法为每个城市创建一个节点后，我调用以下方法来创建道路。

public void initRoads(){
    for(Node n:myNodes){
        for(String line : myLines){
            String[] split = line.split("\\s+");
            if(split[0].equals(n.cityName)){
                for(Node n2:myNodes){
                    if(split[1].equals(n2.cityName)){
                        Road r1 = new Road(n2,Integer.parseInt(split[2]));
                        Road r2 = new Road(n,Integer.parseInt(split[2]));
                        n.neighbors.add(r1);
                        n2.neighbors.add(r2);
                    }
                }
            }
        }
    }
}

对于所有嵌套的 for 循环，随着城市和边缘数量的增长，这似乎是不可能的。有没有办法在不创建这样的图表的情况下解决这个问题？有没有更简单的方法来创建图表？感谢您的帮助。

Answer 1

一眼看去，这里有几点我觉得可以改进：

1. 您指的是每条道路，就好像它有一个destination。您没有具体说道路是单向道路，因此将道路设为双向道路是有意义的。

2. 您在文件中循环了两次 - 为什么？读完一行后，添加两个城市（或在Dictionary中找到），添加道路。

3. 对城市使用Dictionary，而不是列表。这样您可以更快地找到城市，并跳过initRoads() 中的第一个（和第二个）循环。

4. 我还将道路视为具有 ID、两个城市和距离的类。如果需要，每个城市都可以保存与其相连的道路列表。

我不是 Java 本地人，但总体思路应该是这样的：

    public class Node {
        public Node parent;
        public final String cityName;
        public double pathCost;
        public int[] roads;

        public Node(String x){
            cityName = x;
        }

        public String myCity(){
            return cityName;
        }
    }

    public class Road {
        public final int ID;
        public final double distance;

        public Road(int id, double cost){
            ID = id;
            distance = cost;
        }
    }

    public Dictionary<String> cities = new Dictionary<String>();

    public void initNodes(){
        int curID = 0;
        Node first, second;
        for(String line : myLines){
            String[] split = line.split("\\s+");
            first = getNode(split[0]);
            second = getNode(split[1]);

            Road r1 = new Road(curID,split[2]);
            first.roads.add(curID);
            second.roads.add(curID);
            curID++;        
        }       
    }

    // Like a singleton...
    public void getNode(string cityName){

        if(!cities.contains(cityName))
        {
            Node newCity = new Node(cityName);
            cities.add(cityName, newCity);
        }
        return cities.get(cityName);    
    }