LeetCode Weekly Contest 186

5392. 分割字符串的最大得分

给你一个由若干 0 和 1 组成的字符串 s ，请你计算并返回将该字符串分割成两个 非空 子字符串（即 左 子字符串和 右 子字符串）所能获得的最大得分。

「分割字符串的得分」为 左 子字符串中 0 的数量加上 右 子字符串中 1 的数量。

示例 1：

输入：s = “011101”
输出：5
解释：
将字符串 s 划分为两个非空子字符串的可行方案有：
左子字符串 = “0” 且 右子字符串 = “11101”，得分 = 1 + 4 = 5
左子字符串 = “01” 且 右子字符串 = “1101”，得分 = 1 + 3 = 4
左子字符串 = “011” 且 右子字符串 = “101”，得分 = 1 + 2 = 3
左子字符串 = “0111” 且 右子字符串 = “01”，得分 = 1 + 1 = 2
左子字符串 = “01110” 且 右子字符串 = “1”，得分 = 2 + 1 = 3
示例 2：

输入：s = “00111”
输出：5
解释：当 左子字符串 = “00” 且 右子字符串 = “111” 时，我们得到最大得分 = 2 + 3 = 5
示例 3：

输入：s = “1111”
输出：3

提示：

2 <= s.length <= 500
字符串 s 仅由字符 ‘0’ 和 ‘1’ 组成。

思路

遍历。假设s的长度为n，则时间复杂度为O(n)

代码

class Solution:
    def maxScore(self, s: str) -> int:
        left = 0
        right = 0
        cur_max = 0
        n = len(s)
        for ch in s:
            if ch == '1':
                right += 1
        for i, ch in enumerate(s):
            if i  == n - 1:
                break
            if ch == '0':
                left += 1
            elif ch == '1':
                right -= 1
            cur_max = max(cur_max, left + right)
        return cur_max

5393. 可获得的最大点数

几张卡牌 排成一行，每张卡牌都有一个对应的点数。点数由整数数组 cardPoints 给出。

每次行动，你可以从行的开头或者末尾拿一张卡牌，最终你必须正好拿 k 张卡牌。

你的点数就是你拿到手中的所有卡牌的点数之和。

给你一个整数数组 cardPoints 和整数 k，请你返回可以获得的最大点数。

示例 1：

输入：cardPoints = [1,2,3,4,5,6,1], k = 3
输出：12
解释：第一次行动，不管拿哪张牌，你的点数总是 1 。但是，先拿最右边的卡牌将会最大化你的可获得点数。最优策略是拿右边的三张牌，最终点数为 1 + 6 + 5 = 12 。
示例 2：

输入：cardPoints = [2,2,2], k = 2
输出：4
解释：无论你拿起哪两张卡牌，可获得的点数总是 4 。
示例 3：

输入：cardPoints = [9,7,7,9,7,7,9], k = 7
输出：55
解释：你必须拿起所有卡牌，可以获得的点数为所有卡牌的点数之和。
示例 4：

输入：cardPoints = [1,1000,1], k = 1
输出：1
解释：你无法拿到中间那张卡牌，所以可以获得的最大点数为 1 。
示例 5：

输入：cardPoints = [1,79,80,1,1,1,200,1], k = 3
输出：202

提示：

1 <= cardPoints.length <= 10^5
1 <= cardPoints[i] <= 10^4
1 <= k <= cardPoints.length

思路

问题转化为从cardPoints中取连续的n-k个（n为cardPoints的长度），使得它们的和最小。时间复杂度O(n)

代码

class Solution:
    def maxScore(self, cardPoints: List[int], k: int) -> int:
        sumAll = sum(cardPoints)
        n = len(cardPoints)
        if n == k:
            return sumAll
        cur = sum(cardPoints[:(n-k)])
        cur_min = cur
        for i in range(1, k+1):
            cur -= cardPoints[i-1]
            cur += cardPoints[i-1+n-k]
            if cur < cur_min:
                cur_min = cur
        return sumAll - cur_min

5394. 对角线遍历 II

给你一个列表 nums ，里面每一个元素都是一个整数列表。请你依照下面各图的规则，按顺序返回 nums 中对角线上的整数。

示例 1：

输入：nums = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,4,2,7,5,3,8,6,9]
示例 2：

输入：nums = [[1,2,3,4,5],[6,7],[8],[9,10,11],[12,13,14,15,16]]
输出：[1,6,2,8,7,3,9,4,12,10,5,13,11,14,15,16]
示例 3：

输入：nums = [[1,2,3],[4],[5,6,7],[8],[9,10,11]]
输出：[1,4,2,5,3,8,6,9,7,10,11]
示例 4：

输入：nums = [[1,2,3,4,5,6]]
输出：[1,2,3,4,5,6]

提示：

1 <= nums.length <= 10^5
1 <= nums[i].length <= 10^5
1 <= nums[i][j] <= 10^9
nums 中最多有 10^5 个数字。

思路

把二维锯齿数组转化为一个三元组序列，三元组是『元素值』，『行号』，『列号』的组合。将该三元组序列按照第一字段为（『行号』 + 『列号』），第二字段为『列号』排序，然后顺序输出『元素值』即可。
假设二维锯齿数组中的元素个数为n，则时间复杂度为O(nlogn).

代码

class Solution:
    def findDiagonalOrder(self, nums: List[List[int]]) -> List[int]:
        arr = [(val, row, col) for row, lst in enumerate(nums) for col, val in enumerate(lst)]
        arr.sort(key=lambda x: (x[1] + x[2], x[2]))
        return [val for (val, _, _) in arr]

5180. 带限制的子序列和

给你一个整数数组 nums 和一个整数 k ，请你返回 非空 子序列元素和的最大值，子序列需要满足：子序列中每两个 相邻 的整数 nums[i] 和 nums[j] ，它们在原数组中的下标 i 和 j 满足 i < j 且 j - i <= k 。

数组的子序列定义为：将数组中的若干个数字删除（可以删除 0 个数字），剩下的数字按照原本的顺序排布。

示例 1：

输入：nums = [10,2,-10,5,20], k = 2
输出：37
解释：子序列为 [10, 2, 5, 20] 。
示例 2：

输入：nums = [-1,-2,-3], k = 1
输出：-1
解释：子序列必须是非空的，所以我们选择最大的数字。
示例 3：

输入：nums = [10,-2,-10,-5,20], k = 2
输出：23
解释：子序列为 [10, -2, -5, 20] 。

提示：

1 <= k <= nums.length <= 10^5
-10^4 <= nums[i] <= 10^4

思路

动态规划 + 滑动窗口. 假设nums的长度为n, 则总的算法时间复杂度为O(n)：其中动态规划使用一重循环，动态规划部分时间复杂度O(n)；nums的每个元素在滑动窗口中出队入队各一次，滑动窗口时间复杂度O(n).

动态规划

dp[i]表示以nums[i]结尾的子序列的和的最大值

滑动窗口

滑动窗口是这样一个基于双端队列的数据结构，它维护了此刻有效窗口内的k个元素的最大值，队列值总是降序的。每次窗口滑动时，将双端队列内过期的元素删掉（因此元素的类型是一个自定义类包括元素值和元素的位置），将新的元素放入双端队列尾部时，将队列尾部内比新元素小的元素出队（保证队列降序）。滑动窗口的最大值就是双端队列的首元素。

代码

class Solution {    
    private class Value {
        public int val, idx;
        
        public Value(int _val, int _idx) {
            val = _val;
            idx = _idx;
        }
    }
    
    public int constrainedSubsetSum(int[] nums, int k) {
        int n = nums.length, i = 0, bound = 0, gap = 0, ans = Integer.MIN_VALUE;
        int[] dp = new int[n];
        dp[0] = nums[0];
        ans = Math.max(dp[0], ans);
        LinkedList<Value> dq = new LinkedList<>();
        dq.add(new Value(dp[0], 0));
        for (i=1; i<n; ++i) {
            // dynamic programming
            dp[i] = Math.max(dq.getFirst().val, 0) + nums[i];
            ans = Math.max(dp[i], ans);
            
            // sliding window
            if (dp[i] >= dq.getFirst().val) {
                dq.clear();
                dq.add(new Value(dp[i], i));
            } else {
                while (!dq.isEmpty() && dq.getLast().val <= dp[i]) {
                    dq.removeLast();
                }
                dq.add(new Value(dp[i], i));
                while (!dq.isEmpty() && dq.getFirst().idx <= i - k) {
                    dq.removeFirst();
                }
            }
        }
        return ans;
    }
}