如何将网格中单元格的邻居存储到优先级队列中

Question

假设我有一个4乘4的网格，所以有16个单元格。每个单元格包含一个介于1,5之间的值。如。

     0 1 2 3
     _ _ _ _
0 - |2|1|3|2|
1 - |1|3|5|1|
2 - |5|2|1|4|
3 - |2|4|2|1|

现在我知道我需要使用Dijkstra算法。为了优化这一点，我需要使用优先级队列。

我的目标是找到到达目的地的每个单元格的最短总和。源在网格上可以是随机的，目标也可以是随机的。（即并非总是从左上到右下）。

我曾经研究过使用邻接矩阵的图。但是，使用此网格创建相邻矩阵是否明智？i、 e.将所有非相邻字段设置为无穷大。将单元格插入优先级队列的最充分方式是什么？是{（行，列），距离}吗？

我的理解是，优先级队列将存储最佳路径？所以细胞和累积距离。因为，Dijstra的算法使用BFS，在这种情况下，BFS将搜索所有邻居的最短距离。

Answer 1

使'Node'类具有3个字段（行，列，距离）并实现可比。然后使用使用PriorityQueue

import java.util.PriorityQueue;

class Main {

    public static void main(String[] args) {
        PriorityQueue<Node> pq = new PriorityQueue<>();
        pq.add(new Node(2, 3, 12));
        pq.add(new Node(0, 9, 1));
        pq.add(new Node(4, 0, 8));

        System.out.println(pq.poll().getDistance()); //prints 1
    }
}

class Node  implements Comparable<Node>{

    private final int row, col, distance;

    public Node(int row, int col, int value) {
        this.row = row;
        this.col = col;
        distance = value;
    }

    int getDistance() {
        return distance;
    }

    @Override
    public int compareTo(Node other) {
        return Integer.compare(distance, other.distance);
    }
}

或者，将一个Comperator设置到优先级队列，这样节点就不必实现compariable：

import java.util.PriorityQueue;

class Main {

    public static void main(String[] args) {
        PriorityQueue<Node> pq = new PriorityQueue<>(Node::compare);
        pq.add(new Node(2, 3, 12));
        pq.add(new Node(0, 9, 1));
        pq.add(new Node(4, 0, 8));

        System.out.println(pq.poll().getDistance()); //prints 1
    }
}

class Node{

    private final int row, col, distance;

    public Node(int row, int col, int value) {
        this.row = row;
        this.col = col;
        distance = value;
    }

    int getDistance() {
        return distance;
    }

    public static int compare(Node o1, Node o2) {
        return Integer.compare(o1.getDistance(), o2.getDistance());
    }
}

您还可以使用lambda表达式设置comperator:


PriorityQueue

这三个选项都有效。