[Una pregunta del día] Force 1046. El peso de la última piedra

Descripción del título ( portal )

Hay un montón de piedras y el peso de cada piedra es un número entero positivo.

En cada ronda, elija las dos piedras más pesadas de ellas y luego rómpalas. Suponga que el peso de la piedra es xey, y x <= y. Los posibles resultados de la trituración son los siguientes:

Si x == y, entonces ambas piedras se triturarán por completo;
si x! = Y, entonces la piedra de peso x se triturará por completo, y el nuevo peso de la piedra de peso y es yx.
Al final, como mucho solo quedará una piedra. Devuelve el peso de esta piedra. Si no quedan piedras, devuelve 0.

Ejemplo:

输入：[2,7,4,1,8,1]
输出：1
解释：
先选出 7 和 8，得到 1，所以数组转换为 [2,4,1,1,1]，
再选出 2 和 4，得到 2，所以数组转换为 [2,1,1,1]，
接着是 2 和 1，得到 1，所以数组转换为 [1,1,1]，
最后选出 1 和 1，得到 0，最终数组转换为 [1]，这就是最后剩下那块石头的重量。

Ideas para resolver problemas

Método 1: ordenar la violencia

Ordene la matriz de piedras, luego reste las dos más grandes, actualice la diferencia al subíndice len-1 y actualice la otra a 0. Ordene la matriz. .
Sigue girando así, después de cada clasificación, se garantiza que se restan los dos valores máximos, y el bucle termina, y el valor máximo restante es el peso de la última piedra restante.

public int lastStoneWeight(int[] stones) {
    
    
        Arrays.sort(stones);
        int len = stones.length;
        while (len-- >=0) {
    
    
            stones[stones.length-1] = stones[stones.length-1] - stones[stones.length - 2];
            stones[stones.length-2] = 0;
            Arrays.sort(stones);
        }
        return stones[stones.length - 1];
    }

Método 2: pila superior grande

Análisis en profundidad de PriorityQueue

Use la cola de prioridad PriorityQueue para lograr una pila grande, el uso relacionado se puede ver API y código fuente.
Método de construcción:

método de interfaz:

public int lastStoneWeight(int[] stones) {
    
    
         PriorityQueue<Integer> priorityQueue = new PriorityQueue<Integer>((a, b) -> b - a);
         /**
			 * 重写compare方法。
			 * 在此体现了所谓的"自定义"：即根据自己所写逻辑来决定实现最大/小堆
			 */
		// a-b  则是小根堆
        for (int stone : stones
                ) {
    
    
            priorityQueue.offer(stone);
        }

        
        while (priorityQueue.size() > 1) {
    
    
            int a = priorityQueue.poll();
            int b = priorityQueue.poll();
            if (a - b > 0) {
    
    
                priorityQueue.offer(a - b);
            }
        }
        return priorityQueue.isEmpty()?0:priorityQueue.poll();
    }