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;
    }
}