最后一块石头的重量

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

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

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

这题我一开始用的是vector排序，然后删除增加指定元素，用了insert,erase.不过最后有问题。报出了地址相关错误

class Solution {
public:
    int lastStoneWeight(vector<int>& stones) {
        sort(stones.begin(),stones.end());
        int tmp;
        while(stones.size()>1)
        {
            int a=stones[stones.size()-1];
            int b=stones[stones.size()-2];
            stones.erase(stones.begin()+(stones.size()-2));
            stones.erase(stones.end());
            if(a!=b)
            {
                int c=a-b;
                for(int i=0;i<stones.size();i++)
                {
                    if(stones[i]>=c)
                    {
                        tmp=i;
                        break;
                    }
                }
                stones.insert(stones.begin()+tmp,c);
            }
        }
        if(stones.size()==0)
        {
            return 0;
        }
        else
        {
            return stones[0];
        }
        
    }
};

第二种可以用优先队列来进行。

class Solution {
public:
    int lastStoneWeight(vector<int>& stones) {
        priority_queue<int> q;
        for (int s: stones) {
            q.push(s);
        }

        while (q.size() > 1) {
            int a = q.top();
            q.pop();
            int b = q.top();
            q.pop();
            if (a > b) {
                q.push(a - b);
            }
        }
        return q.empty() ? 0 : q.top();
    }
};

优先队列默认是大顶堆降序的。

还有一种不用删除元素的办法

class Solution {
public: 
        int lastStoneWeight(vector<int>& stones) {
        int r=stones.size()-1;
        for(;r>=1;r--){
            sort(stones.begin(),stones.end());
            stones[r-1]=stones[r]-stones[r-1];
        }
        return stones[0];
    }
};

但是不是很常规，并且每次都排序或许更浪费时间。不建议