2020-12-29 LeetCode 每日亿题 1046 最后一块石头的重量+301. 删除无效的括号

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 <= stones.length <= 30
1 <= stones[i] <= 1000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/last-stone-weight

简单题，按题目要求写就完事，每次拿出两个最大的，然后求差值绝对值，这里用到了优先队列，用于保证数列始终从大到小排序，且每次取出来就是最大值（按从小到大排序取得第一个值），放进去就插入到合适的位置，保持队列的有序

class Solution {
    public int lastStoneWeight(int[] stones) {
        PriorityQueue<Integer> pq = new PriorityQueue<>((o1, o2) -> o2-o1);
        for(int stone:stones){
            pq.offer(stone);
        }

        while(pq.size()>1){
            int a = pq.poll();
            int b = pq.poll();
            if(a!=b)
                pq.offer(Math.abs(a-b));
        }

        return pq.isEmpty()?0:pq.peek();
    }
}

今日的困难题：
301. 删除无效的括号
删除最小数量的无效括号，使得输入的字符串有效，返回所有可能的结果。

说明: 输入可能包含了除 ( 和 ) 以外的字符。

示例 1:

输入: "()())()"
输出: ["()()()", "(())()"]

示例 2:

输入: "(a)())()"
输出: ["(a)()()", "(a())()"]

示例 3:

输入: ")("
输出: [""]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-invalid-parentheses

这题一开始没想出来，看了题解后，有点思路写了一段超长的代码，意思和题解一样，但是对于计算删除括号的数量这一步以及判断结果是否为有效括号这两步操作，写的不太好，计算删除括号的数量，用到了32 最长有效括号这题的最后一种方法，从左到右计数，右>左，说明这个右括号是无效的；从右到左计数，左>右，说明这个左括号是无效的。有点是增加了剩余总数和剩余删除数的比较，有效进行了剪枝，我的代码如下：

class Solution {
    public List<String> removeInvalidParentheses(String s) {
        Set<String> res = new HashSet<>();
        int deleteLeft = 0;
        int deleteRight = 0;
        int left = 0;
        int right = 0;
        int totalLeft = 0;
        int totalRight = 0;
        int m = s.length();
        //计算左右删除数，代码比不上官方题解
        for(int i = 0; i < m; i++){
            if(s.charAt(i)=='('){
                ++left;
                ++totalLeft;
            }else if(s.charAt(i)==')'){
                ++right;
                ++totalRight;
            }
            if(right > left){
                ++deleteRight;
                left = 0;
                right = 0;
            }
        }
        left = 0;
        right = 0;
        for(int i = m-1; i >= 0; i--){
            left = s.charAt(i)=='('?left+1:left;
            right = s.charAt(i)==')'?right+1:right;
            if(right<left){
                ++deleteLeft;
                left = 0;
                right = 0;
            }
        }


        return new ArrayList<>(dfs(res,totalLeft,totalRight,deleteLeft,deleteRight,0,s,new StringBuilder()));
    }

        private Set<String> dfs(Set<String> res, int totalLeft, int totalRight, int deleteLeft, int deleteRight, int pos,String s, StringBuilder sb) {
            if(pos == s.length()){
                if(isEffective(sb.toString()))
                    res.add(sb.toString());
                return res;
            }

            if(s.charAt(pos)=='('){
            //剪枝，剩余总数>删除数才能追加不进行删除
                if(totalLeft>deleteLeft){
                    sb.append("(");
                    res.addAll(dfs(res,totalLeft-1,totalRight,deleteLeft,deleteRight,pos+1,s,sb));
                    sb.deleteCharAt(sb.length()-1);
                }
                if(deleteLeft>0){
                    res.addAll(dfs(res,totalLeft-1,totalRight,deleteLeft-1,deleteRight,pos+1,s,sb));
                }
            }else if(s.charAt(pos)==')'){
            //剪枝，剩余总数>删除数才能追加不进行删除
                if(totalRight>deleteRight){
                    sb.append(")");
                    res.addAll(dfs(res,totalLeft,totalRight-1,deleteLeft,deleteRight,pos+1,s,sb));
                    sb.deleteCharAt(sb.length()-1);
                }

                if(deleteRight>0){
                    res.addAll(dfs(res,totalLeft,totalRight-1,deleteLeft,deleteRight-1,pos+1,s,sb));
                }
            }else{
                sb.append(s.charAt(pos));
                res.addAll(dfs(res,totalLeft,totalRight,deleteLeft,deleteRight,pos+1,s,sb));
                sb.deleteCharAt(sb.length()-1);
            }
            return res;
        }

		//计算有效性，比不上官方题解
        private boolean isEffective(String s){
        int left = 0;
        int right = 0;
        int m = s.length();
        for(int i = 0; i < m; i++){
            left = s.charAt(i)=='('?left+1:left;
            right = s.charAt(i)==')'?right+1:right;
            if(right > left){
                left = 0;
                right = 0;
                return false;
            }
        }
        left = 0;
        right = 0;
        for(int i = m-1; i >= 0; i--){
            left = s.charAt(i)=='('?left+1:left;
            right = s.charAt(i)==')'?right+1:right;
            if(right<left){
                left = 0;
                right = 0;
                return false;
            }
        }

        return true;
    }

}

力扣官方的题解：

    class Solution {

        private Set<String> validExpressions = new HashSet<String>();
        public List<String> removeInvalidParentheses(String s) {

            //计算左右删除括号数，官方优势
            int left = 0, right = 0;
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == '(') {
                    left++;
                } else if (s.charAt(i) == ')') {
                    right = left == 0 ? right + 1 : right;
                    left = left > 0 ? left - 1 : left;
                }
            }

            this.recurse(s, 0, 0, 0, left, right, new StringBuilder());
            return new ArrayList<>(this.validExpressions);
        }
        private void recurse(
                String s,
                int index,
                int leftCount,
                int rightCount,
                int leftRem,
                int rightRem,
                StringBuilder expression) {

            if (index == s.length()) {
                //比较删除数，官方劣势
                if (leftRem == 0 && rightRem == 0) {
                    this.validExpressions.add(expression.toString());
                }

            } else {
                char character = s.charAt(index);
                int length = expression.length();

                //如果可以删，那就删掉试试
                if ((character == '(' && leftRem > 0) || (character == ')' && rightRem > 0)) {
                    this.recurse(
                            s,
                            index + 1,
                            leftCount,
                            rightCount,
                            leftRem - (character == '(' ? 1 : 0),
                            rightRem - (character == ')' ? 1 : 0),
                            expression);
                }

                expression.append(character);

                if (character != '(' && character != ')') {
                    this.recurse(s, index + 1, leftCount, rightCount, leftRem, rightRem, expression);
                } else if (character == '(') {
                    this.recurse(s, index + 1, leftCount + 1, rightCount, leftRem, rightRem, expression);
                } else if (rightCount < leftCount) {
                    //保证右<=左，这步保证了现有括号的有效性，官方优势
                    this.recurse(s, index + 1, leftCount, rightCount + 1, leftRem, rightRem, expression);
                }

                expression.deleteCharAt(length);
            }
        }
    }

思考：如果把两个合起来会不会更好呢？