最后一块石头的重量20201230

0. 题目

最后一块石头的重量

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

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

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

示例：
	输入：[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]，这就是最后剩下那块石头的重量。

提示：

• 1 <= stones.length <= 30
• 1 <= stones[i] <= 1000

1. 大顶堆法

1.1 分析

主要思路：官方推荐这种解法；

• 维持一个大顶堆，每次取出值后堆顶都是最大值；
• 依次取出两个元素a和b，a必定大于等于b；
• 如果a不等于b那么把差值放入队列，
• 当队列大小小于1时则返回，为空则表明都粉碎可，否则取出元素为剩余的石头重量；

大顶堆比较简洁，但是每取出一个元素都需要维持大顶堆，因此比较耗时；

1.2 代码 2 ms 35.8 MB

public int lastStoneWeight1(int[] stones) {
	PriorityQueue<Integer> queue = new PriorityQueue<Integer>((a, b) -> b -a);
	for (Integer temp : stones) {
		queue.offer(temp);
	}
	
	while (queue.size() > 1) {
		int a = queue.poll();
		int b = queue.poll();
		if (a != b) {
			queue.offer(a-b);
		}
	}
	return queue.isEmpty()? 0: queue.poll();
}

2. 排序法

2.1 分析

主要思路：

• 先对原始数组快排，取出数组尾部最大的两个值；
• 若相等则赋值为0重排序，否则赋值差值重排序；
• 再取出排序，重复上一步；
• 若两值某个值为0则结束，直接返回返回末尾元素；

这种方法也比较简单，相对上面的方法少排序。

2.2 代码 1 ms 35.7 MB

public int lastStoneWeight(int[] stones) {
	if (stones == null || stones.length == 0) return 0;
        if (stones.length == 1) return stones[0];
		quickSort(stones);
		int len = stones.length;
		while (stones[len-2] != 0 && stones[len-1] != 0) {
			if (stones[len-1] == stones[len-2]) {
				stones[len-2] = 0;
				stones[len-1] = 0;
			} else {
                stones[len-1] = Math.abs(stones[len-1]-stones[len-2]);
				stones[len-2] = 0;
			}
			quickSort(stones);
		}
		return stones[len-1];
}

// 数组排序
public static void quickSort(int[] array) {
    int len;
    if(array == null
            || (len = array.length) == 0
            || len == 1) {
        return ;
    }
    sort(array, 0, len - 1);
}

/**
 * 快排核心算法，递归实现
 * @param array
 * @param left
 * @param right
 */
public static void sort(int[] array, int left, int right) {
    if(left > right) {
        return;
    }
    // base中存放基准数
    int base = array[left];
    int i = left, j = right;
    while(i != j) {
        // 顺序很重要，先从右边开始往左找，直到找到比base值小的数
        while(array[j] >= base && i < j) {
            j--;
        }

        // 再从左往右边找，直到找到比base值大的数
        while(array[i] <= base && i < j) {
            i++;
        }

        // 上面的循环结束表示找到了位置或者(i>=j)了，交换两个数在数组中的位置
        if(i < j) {
            int tmp = array[i];
            array[i] = array[j];
            array[j] = tmp;
        }
    }

    // 将基准数放到中间的位置（基准数归位）
    array[left] = array[i];
    array[i] = base;

    // 递归，继续向基准的左右两边执行和上面同样的操作
    // i的索引处为上面已确定好的基准值的位置，无需再处理
    sort(array, left, i - 1);
    sort(array, i + 1, right);
}