Java 将PriorityQueue用作minHeap

当试图解决这个问题时 我试着总是摘下一片叶子，然后把它的重量和它连接的节点结合起来。 我使用PriorityQueue来存储所有节点，并使用它们相邻节点的大小作为优先级。但是当我尝试一些测试用例时，似乎违反了优先级队列属性，这意味着非叶节点可能出现在叶节点之前。PriorityQueue是否会自动更新自身，或者我是否应该调用一些函数来更新它。我的临时解决方案是使用一个列表来存储所有的叶子

以下是我的代码：

public class Solution {
    private static class Node implements Comparable<Node> {
        int index;
        int value;
        Map<Integer, Node> adj;

        public Node(int index, int value) {
            this.index = index;
            this.value = value;
            this.adj = new HashMap<Integer, Node>();
        }

        @Override
        public int compareTo(Node n) {
            return adj.size() - n.adj.size();
        }
    }

    public static void main(String[] args) {

        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(new FileInputStream("input.txt")));

            int total = 0;

            int N = Integer.parseInt(br.readLine());
            String[] strs = br.readLine().split(" ");
            HashMap<Integer, Node> nodes = new HashMap<Integer, Node>();

            for (int i = 0; i < N; i++) {
                int value = Integer.parseInt(strs[i]);
                nodes.put(i, new Node(i, value));
                total += value;
            }

            for (int i = 0; i < N - 1; i++) {
                strs = br.readLine().split(" ");
                int n1 = Integer.parseInt(strs[0]) - 1;
                int n2 = Integer.parseInt(strs[1]) - 1;

                nodes.get(n1).adj.put(n2, nodes.get(n2));
                nodes.get(n2).adj.put(n1, nodes.get(n1));
            }

            // PriorityQueue<Node> pq = new PriorityQueue<Node>(nodes.values());
            // while (!pq.isEmpty()) {
            // Node n = pq.poll();
            // System.out.println(n.index + " " + n.adj.size());
            // }
            // NOTE: java's PriorityQueue doesn't support update, cannot use it
            // LAME DESIGN. use a LinkedList instead

            List<Node> leaves = new LinkedList<Node>();
            for (Node node : nodes.values()) {
                if (node.adj.size() == 1) {
                    leaves.add(node);
                }
            }

            int minDiff = Integer.MAX_VALUE;

            while (!leaves.isEmpty()) {
                // get a leaf node
                // Node leaf = pq.poll();
                Node leaf = leaves.get(0);

                leaves.remove(0);
                if (leaf.adj.size() <= 0)// last node
                    break;

                int diff = Math.abs((total - leaf.value) - leaf.value);
                if (diff < minDiff)
                    minDiff = diff;

                // combind leaf to it's connection
                Node conn = null;
                for (Node node : leaf.adj.values()) {
                    conn = node;
                }

                conn.value += leaf.value;
                conn.adj.remove(leaf.index);
                if (conn.adj.size() == 1)
                    leaves.add(conn);
                nodes.remove(leaf.index);
            }

            System.out.println(minDiff);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

公共类解决方案{
私有静态类节点实现可比较的{
整数指数；
int值；
地图；
公共节点（int索引，int值）{
这个指数=指数；
这个值=值；
this.adj=新HashMap（）；
}
@凌驾
公共整数比较（节点n）{
返回调整大小（）-n.adj.size（）；
}
}
公共静态void main（字符串[]args）{
BufferedReader br=null；
试一试{
br=新的BufferedReader（新的InputStreamReader（新文件InputStream（“input.txt”））；
int-total=0；
int N=Integer.parseInt（br.readLine（））；
字符串[]strs=br.readLine（）.split（“”）；
HashMap节点=新的HashMap（）；
对于（int i=0；i如果（leaf.adj.size（）标准Java PriorityQueue不支持更新。如果需要删除项，则必须实现自己的minHeap。删除堆中的某些项时，请调用heapify

可以找到实现和解释！
PrioirtyQueue
没有实现，但是
LinkedHashMap
有，它们是
RemoveedStantry

根据：

Removeedestentry（映射条目）
方法可能会被重写，以便在将新映射添加到映射时强制执行自动删除过时映射的策略。
PriorityQueue中可能存在只需要更新而不需要删除的非叶节点。我还认为可以使用列表来存储所有叶节点，就像在代码中实现的那样。感谢您的帮助材料