1046. 最后一块石头的重量（Java）

1046. 最后一块石头的重量

有一堆石头，每块石头的重量都是正整数。

每一回合，从中选出两块最重的石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块石头。返回此石头的重量。如果没有石头剩下，就返回 0。

思路：使用递归
每次用最大的两个数的差来代替最大的两个数
注意：java数组在创建时长度就不能改变，因此用0和最大的两个数的差来代替最大两个数，当排序后的倒数第三个数为0时，说明只剩下两个非0值或1个非0值，可直接返回结果

class Solution {
    public int lastStoneWeight(int[] stones) {
    	   //递归：每次使用最大两个数的差代替最大两个数
    	   //注意：数组长度在初始化时就已经固定了，缩短数组时空出来的位置用 0 代替,当倒数第三个数为0时说明只剩下两个数或1个数
    	   Arrays.sort(stones);
    	   if(stones.length==2) {
    		   return stones[1]-stones[0];
    	   }
    	   else if (stones.length==1) {
    		   return stones[0];
    	   }
    	   else if (stones.length==0) {
    		   return 0;
    	   }
    	   else {
    		   if(stones[stones.length-3]==0)
    			   return stones[stones.length-1]-stones[stones.length-2];
    		   stones[stones.length-2]=stones[stones.length-1]-stones[stones.length-2];
    		   stones[stones.length-1]=0;
    		   return lastStoneWeight(stones);
    	   }
        
    }
}

缺点：当stones.length大时，时间复杂度O(n^2logn)

2.使用非递归
将已粉碎的石头计为0

class Solution {
    public int lastStoneWeight(int[] stones) {
    	   if(stones.length==2) {
    		   return Math.abs(stones[1]-stones[0]);
    	   }
    	   else if (stones.length==1) {
    		   return stones[0];
    	   }
    	   else if (stones.length==0) {
    		   return 0;
    	   }
    	   int len=stones.length;
    	   for(int i=0;i<len-1;i++) {
    		   //共执行了len-1次
    		   Arrays.sort(stones);
    		   stones[len-1]=stones[len-1]-stones[len-2];
    		   stones[len-2]=0;
    	   }
    	   return stones[len-1];
        
    }
}

3.官方解法：使用优先队列（最大堆）

最大堆的堆顶元素为当前最大，优先队列每次出队的为优先级最大的元素（优先级：可由Comparator自定义，默认为元素本身的自然顺序的升序）

将所有石头的重量放入最大堆中。每次依次从队列中取出最重的两块石头 a 和 b，必有 a≥b。如果 a>b，则将新石头 a-b 放回到最大堆中；如果 a=b，两块石头完全被粉碎，因此不会产生新的石头。重复上述操作，直到剩下的石头少于 2 块。
最终可能剩下 1 块石头，该石头的重量即为最大堆中剩下的元素，返回该元素；也可能没有石头剩下，此时最大堆为空，返回 0。

class Solution {
    public int lastStoneWeight(int[] stones) {
    //自定义降序比较器
        PriorityQueue<Integer> pq = new PriorityQueue<Integer>((a, b) -> b - a);
        for (int stone : stones) {
            pq.offer(stone);
        }

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

时间复杂度：
时间复杂度：O(nlogn)，其中 n 是石头数量。每次从队列中取出元素需要花费 O(logn) 的时间，即从大跟堆中取堆顶元素，最多共需要粉碎 n−1 次石头（即每次取出两块石头的大小都不相等）。

本文地址：https://blog.csdn.net/weixin_43786147/article/details/111991889