【周赛总结】第32场双周赛，第201场周赛

2020/08/09 未参加

第32场双周赛

1541.平衡括号字符串的最少括号数

对于括号问题，似乎分情况讨论比较好。一般可以考虑维护两个变量，分别表示目前可使用的(和)的数量。这道题目有点偏方法。

class Solution {
    public int minInsertions(String s) {
        int left = 0, ans = 0, n = s.length();
        for(int i = 0; i<n;i++){
        // 分别考察现在是(还是)的情况。
            if (s.charAt(i) == '(') left++;
            else{
                if (i+1<n && s.charAt(i+1) == ')') i++; // 寻找第二个)括号
                else ans++; //否则添加第二个
                if (left > 0) left--; // 前面已经满足了两个))，消除一个(
                else ans++; // 添加一个(
            }
        }
        // 如果最后有多的(
        ans += left*2;
        return ans;
    }
}

1542.最长超赞回文串

题目的特点是子串，并且要找到最长子串。这个点很容易想到dp或者前缀和的方法。但是要求是回文串，回文串的点在于只能由最多一个奇数。并且我们需要考察前面的全部字符的个数。因此，这种考察多个字符的状态的问题，典型的方法就是状态压缩。

每次前缀和都是异或，并且我们子循环是每次考虑一个one hot的值。如果这个onehot可以与cur异或得到一个出现过的值，说明中间的某一段的异或和一定位onehot的，也就是满足以后一个奇数个。

如果cur是重复的，说明存在中间的某一段全部都是偶数的，也是符合的。

注意，初始要把0设置为-1.

class Solution {
    public int longestAwesome(String s) {
        //int[] dic = new int[10];
        // 前缀和+状态压缩
        // 为什么会想到使用状态压缩，因为我们每次要看好几个东西的存在状态。（并且，对于回文串，很强的01性）
        int ans = 0, n = s.length(),cur = 0;
        HashMap<Integer, Integer> dic = new HashMap<>();
        dic.put(0, -1);
        for (int i = 0;i<n;i++){
            int key = s.charAt(i)-'0';
            cur ^= 1<<key;  前缀和
            for (int j = 0; j <10; j++){
                int now = cur ^ (1<<j); 
                 如果出现过，说明有某一段的位的异或和是只有一个1的形式。
                if (dic.containsKey(now)){
                    ans = Math.max(ans, i-dic.get(now));
                }
            }
            if (!dic.containsKey(cur)) dic.put(cur,i);
            else ans = Math.max(ans, i-dic.get(cur));

        }
        return ans;
    }
}

第201场周赛

1544.整理字符串

关键还是练习Java的使用，这次有一个新的方法stack。

• 新建一个栈：Stack<char> stack = new Stack<>()
• 进入栈：stack.push(a);
• 弹出栈顶：stack.pop();
• 查询栈顶：stack.peek()
• 是否空栈：stack.isEmpty()

class Solution {
    public String makeGood(String s) {
        if(s.length() == 0 || s.length() == 1) return s;
        Stack<Character> stack = new Stack<>();
        //遍历s
        for(int i = 0; i < s.length(); i++){
            char cur = s.charAt(i);
            //若栈为空，则直接压栈即可
            if(stack.isEmpty()){
                stack.push(s.charAt(i));
                continue;
            }
            //栈顶元素
            char tmp = stack.peek();
            if(cur-tmp == 32 || cur-tmp == -32){
                stack.pop();
            }else{
                stack.push(cur);
            }
        }
        StringBuilder res = new StringBuilder();
        for (char j:stack){
            res.append(j);
        }
        return res.toString();
    }
}

1547 切棍子的最小成本

看到题目就是可以想到类似于扎气球的区间DP思路，但是这里还是没有分析清楚如何设计dp。
这里正确的方法应该是设计dp=[m+2][m+2]，其中m是前面的cut的长度，前后补了两个边界。每次进行切割的代价其实就是区间的长度。

可以这么理解，dp[i][j]表示第i个切口和第j个切口之间的成本。

注意考虑一下初始的条件，dp[i][i+1]的表示只有其中一段，应该成本是0的。因为中间没有别的切口。

API：

• Arrays.sort(list) 对一个数组进行升序排序。
• Arrays.sort(a, Collections.reverseOrder());降序排列。
• Arrays.fill(int[], int)对一个行向进行填充

如果需要其他的排序方式，需要进行利用collections.sort并且重写compare方法：

Collections.sort(students, new Comparator<Student>() {
    @Override
    public int compare(Integer o1, Integer o2) {
    // 返回一个正数，表示前面大于后面的，负数表示小于
    // 如果调用compare方法大于0，就把前一个数和后一个数交换，也就是把大的数放后面了
   	    /*
         * 如果o1小于o2，我们就返回正值，如果o1大于o2我们就返回负值， 这样颠倒一下，就可以实现降序排序了,反之即可自定义升序排序了
         */
        return o2 - o1;
}); 

class Solution {
    public int minCost(int n, int[] cuts) {
        // 首先需要进行排序，因为我们需要从后往前一次进行dp
        Arrays.sort(cuts);
        int m = cuts.length;
        int[] p = new int[m+2];
        p[0] = 0;
        for (int i = 1; i<m+1; i++) p[i] = cuts[i-1];
        p[m+1] = n;

        int[][] dp = new int[m+2][m+2];
        for (int i = 0; i<=m+1; i++){
            Arrays.fill(dp[i], Integer.MAX_VALUE);
            if(i<m+1) dp[i][i+1] = 0;
        }

        for (int i = m; i>=0; i--){ // 左端点
            for (int j = i+1; j<=m+1;j++){ // 右端点
                int cost = p[j]-p[i]; // 计算这一段切割的成本，正好等于长度
                for(int k = i+1; k<j; k++){ // 分割点，一定得是中间的点
                    dp[i][j] = Math.min(dp[i][j], dp[i][k]+dp[k][j]+cost);
                }
            }
        } 
        return dp[0][m+1];
    }
}