LeetCode每日一题--1046. 最后一块石头的重量（优先队列 大顶堆）

题目：跳转至 1046. 最后一块石头的重量

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

每一回合，从中选出两块 最重的 石头，然后将它们一起粉碎。假设石头的重量分别为 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. 1 <= stones.length <= 30
2. 1 <= stones[i] <= 1000

class Solution {
public:
    int lastStoneWeight(vector<int>& stones) {
        
    }
};

思路：

这题思路还是比较清晰的，每次都选出最重的两块，没被粉碎的继续放入，那就优先队列。

class Solution {
public:
    int lastStoneWeight(vector<int>& stones) {
        priority_queue<int> que;
        for(auto x:stones)
            que.push(x);
        while(que.size()>1){
            int bigone=que.top();
            que.pop();
            int smallone=que.top();
            que.pop();
            if(bigone>smallone)
                que.push(bigone-smallone);
        }
        if(que.empty())
            return 0;
        return que.top();
    }
};

很惊讶的在提交记录里发现 6 个月前用大顶堆提交过一次，不过又忘记了，拎过来再复习一下。

class Solution {
public:
    void buildMaxHeapify(vector<int>& vec,int heapSize){
        for(int i=heapSize/2;i>=0;i--){  //从最后一个有子节点的根开始循环
            MaxHeapify(vec,i,heapSize);
        }
    }
    void MaxHeapify(vector<int>& vec,int i,int heapSize){
        int l=2*i+1,r=2*i+2,largest=i;   //l:左子树 r:右子树 largest:根节点
        if(l<heapSize && vec[l]>vec[largest])
            largest=l;
        if(r<heapSize && vec[r]>vec[largest])
            largest=r;
        if(largest!=i){  //树往下走，如果本来就是根节点那最大堆完成，如果交换了，下面的树可能也要重排
            swap(vec[largest],vec[i]);
            MaxHeapify(vec,largest,heapSize);  //以交换后的节点为根节点进行重排
        }
    }
    int lastStoneWeight(vector<int>& stones) {
        int siz=stones.size();
        buildMaxHeapify(stones,siz);
        int remain;
        int tmpmax;
        for(int i=stones.size()-1;i>0;--i){
            //获取第一个最大值
            tmpmax=stones[0];
            swap(stones[0],stones[i]);
            --siz;
            MaxHeapify(stones,0,siz);
            remain=tmpmax-stones[0];
            stones[0]=remain;
            MaxHeapify(stones,0,siz);
        }
        if(!stones.empty())
            return stones[0];
        else
            return 0;
    }
};

以下图示借鉴了菜鸟教程中的。

大顶堆（大根堆，最大堆），顾名思义，其根节点的值大于等于左右两个子树的结点值，且为完全二叉树，如下图所示：

把堆中结点按层序编号表示为：

[96, 65, 91, 60, 35, 77, 81, 13, 10, 30, 20, 31, 65, 46, 22]

因为是完全二叉树，所以对结点 i，其左子树结点为 2i+1，右子树结点为 2i+2。根据大顶堆定义可得：arr[i]>=arr[2i+1] && arr[i]>=arr[2i+2]。

堆排序中，最重要两个操作就是初始化堆以及调整堆。其中构造初始堆是对所有的非叶结点都进行调整（构建出一个完全二叉树，保证根结点大于等于左右结点），调整堆就是交换第一个元素（根节点最大值）和最后一个元素，输出交换过的最后一个元素，把剩余元素重新调整为最大堆，直至输出最后一个元素。所以，大顶堆排序后其实是一个升序排序的数列。

下面的动图均展示了数组初始化为堆以及排序的过程。