Question

这是我第一次使用地图编写Web应用程序。

我正在尝试使用给定OSM映射中的每个节点创建具有邻接列表的无向图。

当我在小地图上测试时，一切正常我解组OSM映射（它等于XML文件），然后从OSM对象创建我收到的无向图。

当我尝试从较大的地图创建图表时，问题就开始了。

例如，拍摄大小为6MB的地图：
节点数：24828
方式：4535
每种方式平均数为5个节点所有这些将是：24828 * 4535 * 5 = 562,974,900次迭代！

直观地说，为了找到每个节点的邻居，我需要从节点列表中以每个节点2的每个方式遍历每个节点1。如果node1等于node2我需要接下来的＆amp;以前的节点是它的邻居。
我花了大约1:30的时间来做这件事：

我正在构建将在智能手机上运行的Web应用程序，并计算要运行的随机路径如果用户需要等待1:30分钟才能创建图表，那么它将无法使用。

我熟悉BFS \ DFS，但在这种情况下他们不会帮助我，因为我需要构建图表。

也许还有其他有效的方法来为节点创建邻接列表？

我如何建立邻接列表：

public static List<Node> GetNodesFromXML(Osm i_Osm) {
        List<Node> o_Nodes = new ArrayList<Node>();
        long id;
        double latitude;
        double longtitude;
        Map<Node, List<Node>> o_AdjList = new HashMap<Node, List<Node>>();


        for (Osm.Node nodeChild : i_Osm.getNode()) {
            id = nodeChild.getId();
            latitude = nodeChild.getLat();
            longtitude = nodeChild.getLon();
            Node node = new Node(id, latitude, longtitude);

             for (Osm.Way way : i_Osm.getWay()) // go over the node list of the specific way objects
              {
                for (Osm.Way.Nd nd : way.getNd()) {
                    // some manipulation to create the adjacency list
                }
             }

            //List<Long> nodeAdjacenciesByRef = getNodeAdjacenciesByRef(node, i_Osm.getWay(), i_Osm.getNode());
           // List<Edge> nodeAdjacencies = getNodeAdjacencies1(node, i_Osm.getWay(), i_Osm.getNode());
          // List<Edge> nodeAdjacencies = getAdjacenciesListFromRefList(node, nodeAdjacenciesByRef, i_Osm.getNode());
          // node.SetAdjacencies(nodeAdjacencies);
            o_Nodes.add(node);
        }

        for(Node node : o_Nodes)
        {

        }



        o_Nodes = updateAdjacenciesToAllNodes(o_Nodes);

        return o_Nodes;
    }

我用于图表的类：

// Node.java
public class Node implements Comparable<Node>
{

    private long m_Id;
    private List<Edge> m_Adjacencies = new ArrayList<Edge>();
    private double m_Longtitude;
    private double m_Latitude;
    private Node m_Prev; 
    private double m_MinDistance = Double.POSITIVE_INFINITY;  // this is for Dijkstra Algorithm
    //used to reconstruct the track when we found the  approproate length of the user request
    //from the current level to the destination

    public Node(long i_Id, double i_Latitude, double i_Longtitude) 
    {
        m_Id = i_Id;
        m_Latitude = i_Latitude;
        m_Longtitude = i_Longtitude;
    }
    ...
}

// Graph.java
  private List<Node> m_Nodes = new ArrayList<>();
    private List<Way> m_Ways = new ArrayList<>();
    private List<Relation> m_Relations = new ArrayList<>();
    private Bounds m_Bounds;

    public Graph(List<Node> i_Nodes, List<Way> i_Ways, List<Relation> i_Relations, Bounds i_Bounds) {
        m_Nodes = i_Nodes;
        m_Ways = i_Ways;
        m_Relations = i_Relations;
        m_Bounds = i_Bounds;
    }
    ...
}
// Edge.java
public class Edge {

    Node m_Source;
    Node m_Destination;

    double m_Weight;

    public Edge(Node i_Source, Node i_Destination, double i_Weight) {
        m_Source = i_Source;
        m_Destination = i_Destination;
        m_Weight = i_Weight;
    }
    ...
}

编辑：已解决：
我使用了HashMap。通过这种方式，我将能够获得O（1）中的每个节点所以我在所有节点上运行一次（1秒或更短）并创建这个地图在我有这个映射之后，我可以在没有外部循环的情况下以各种方式传递每个节点在重新设计之后，整个事情花了3秒钟。

所以这是解决方案：

   public static List<Node> GetNodesFromXML(Osm i_Osm) {
        List<Node> o_Nodes = new ArrayList<Node>();
        long id;
        double latitude;
        double longtitude;
        Map<Long, Node> o_NodesByRef = new HashMap<Long, Node>();


        for (Osm.Node nodeChild : i_Osm.getNode()) {
            id = nodeChild.getId();
            latitude = nodeChild.getLat();
            longtitude = nodeChild.getLon();
            Node node = new Node(id, latitude, longtitude);
            //o_Nodes.add(node);
            o_NodesByRef.put(id, node);
        }

        o_Nodes = addAdjacencies(o_NodesByRef, i_Osm.getWay());


        //o_Nodes = updateAdjacenciesToAllNodes(o_Nodes);

        return o_Nodes;
    }


     private static List<Node> addAdjacencies(Map<Long, Node> i_NodesByRef , List<Osm.Way> i_Ways) {
        List<Node> o_Nodes = new ArrayList<Node>();
        long ndId;
        int nodeIndex;
        int lastNodeIndex;
        Node previousNode;
        Node nextNode;
        double weight;
        //System.out.println(i_SourceNode.getNodeId());
        for (Osm.Way way : i_Ways) // go over the node list of the specific way objects
                {
            if (way.getNd().size() > 1) {
                for (Osm.Way.Nd nd : way.getNd()) {

                    if(i_NodesByRef.containsKey(nd.getRef()))// found node in way
                    {
                        Node node = i_NodesByRef.get(nd.getRef());
                        nodeIndex = way.getNd().indexOf(nd);
                        Edge edge1;
                        Edge edge2;
                        Osm.Way.Nd temp_nd;
                        lastNodeIndex = way.getNd().size() - 1;

                        if (nodeIndex == 0) // node is the first in the way
                        {
                            temp_nd = way.getNd().get(nodeIndex + 1);
                            nextNode = i_NodesByRef.get(temp_nd.getRef());
                            weight = CoordinateMath.getDistanceBetweenTwoNodes(node, nextNode);
                            edge1 = new Edge(node, nextNode, weight); 
                            i_NodesByRef.get(node.getNodeId()).getAdjacencies().add(edge1);


                        } else if (lastNodeIndex == nodeIndex) // node is the last
                        {
                            temp_nd = way.getNd().get(nodeIndex - 1);
                            previousNode = i_NodesByRef.get(temp_nd.getRef());

                            weight = CoordinateMath.getDistanceBetweenTwoNodes(node, previousNode);
                            edge1 = new Edge(node, previousNode, weight); 
                            i_NodesByRef.get(node.getNodeId()).getAdjacencies().add(edge1);

                        } else // node is in the middle
                        {
                            temp_nd = way.getNd().get(nodeIndex - 1);
                            previousNode = i_NodesByRef.get(temp_nd.getRef());

                            weight = CoordinateMath.getDistanceBetweenTwoNodes(node, previousNode);
                            // node -> previousNode
                            edge1 = new Edge(node, previousNode, weight); 
                            i_NodesByRef.get(node.getNodeId()).getAdjacencies().add(edge1);

                            temp_nd = way.getNd().get(nodeIndex + 1);
                            nextNode = i_NodesByRef.get(temp_nd.getRef());
                            weight = CoordinateMath.getDistanceBetweenTwoNodes(node, nextNode);
                            // node -> nextNode
                            edge2 = new Edge(node, nextNode, weight); 
                            i_NodesByRef.get(node.getNodeId()).getAdjacencies().add(edge2);


                        }
                    }
                }
            }
        }

        for(Map.Entry<Long, Node> entry : i_NodesByRef.entrySet())
         {
                o_Nodes.add(entry.getValue());
         }

        return o_Nodes;
    }

Answer 1

问题是您正在尝试存储元素为整个节点的邻接列表。

Map<Node, List<Node>> o_AdjList = new HashMap<Node, List<Node>>();

这样效率不高，因为该图存储了所有节点信息并占用了大量内存。

相反，我只使用节点ID制作图形，如整数：

Map<Integer, TreeSet<Integer>> o_AdjList = new HashMap<Integer, TreeSet<Integer>>();

并将剩余的节点信息保存在一个单独的更高效的结构中，如HashSet。

这意味着您将使用仅使用整数ID的图形表示，该对象比第一个图形小很多倍。现在，处理器可以缓存更多内容并更快地运行SSSP。

如果您真的想要一个包含实际节点的图形，您可以在以后构建它。这就是我要从way：

构建图表的方法

for (Osm.Way way : i_Osm.getWay()) {
//I will asume the getNd() returns some sort of array or list an you can access the next or previous element
     for (Osm.Way.Nd nd : way.getNd()) {
                if(o_AdjList contains key nd){
                  o.AdjList.get(nd).add(nextNd);
                } else {
                  o.AdjList.put(nd,nextNd);
     }
}

当然，你必须实现一些walk方法，但之后......你已经设置了节点。

如何在线性时间内从大型OSM映射构建具有邻接列表的无向图

1 个答案: