自娱自乐的精神乐园

余凯迪的博客

0%

leetcode_186_contest

发表于 分类于 ， 阅读次数：

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

思路：
先统计数组中所有为1的数量num，使用l记录左边0的数量，然后从第一个位置开始，依次往后遍历。当前位置为0，则l加1，为1则num减1。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution:
    def maxScore(self, s: str) -> int:
        num = 0
        for x in s:
            if x=='1':
                num += 1
        res = 0
        l = 0
        for x in s[:-1]:
            if x == '0':
                l += 1
                res = max(res, l+num)
            else :
                num -= 1
                res = max(res, l+ num)
        return res

1423. 可获得的最大点数

思路：
每次只能从两个端点取数，先假设从左端点取完k个，依次减少从左端点取的个数，减去左边尾部加上右侧端点，遍历取最大值。

1
2
3
4
5
6
7
8
class Solution:
    def maxScore(self, cardPoints: List[int], k: int) -> int:
        num = sum(cardPoints[:k])
        res = num
        for i in range(1,k+1):
            num = num - cardPoints[k-i] + cardPoints[-i]
            res = max(num, res)
        return res

1424. 对角线遍历 II

思路：
容易想到对角线上的坐标之和为定值。此题直接模拟会超时，可以提前用哈希表存储好每条对角线上的值，最后直接对角线即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from collections import defaultdict
class Solution:
    def findDiagonalOrder(self, nums: List[List[int]]) -> List[int]:
        mm = defaultdict(list)
        for i in range(len(nums)):
            for j in range(len(nums[i])):
                mm[i+j].append(nums[i][j])
        n = max(mm.keys())
        res = []
        for i in range(n+1):
            if len(mm[i])==0:
                continue
            for j in range(len(mm[i])-1 ,-1,-1):
                res.append(mm[i][j])
        return res

带限制的子序列和

思路：
很容易想到dp来求解, $dp[i]$ 表示以 $i$ 结尾的最大的子序列和。然后用单调队列存储区间窗口内最大的子序列和。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution:
    def constrainedSubsetSum(self, nums: List[int], k: int) -> int:
        res = nums[0]
        dp = nums[:]
        dp[0] = nums[0]
        s = [0]
        for i in range(1, len(nums)):
            if i-s[0]>k:
                s.pop(0)
            dp[i] = nums[i]
            dp[i] = max(dp[i], dp[s[0]] + nums[i])
            while s and dp[i] >= dp[s[-1]]:
                s.pop()
            s.append(i)
            
            res = max(res, dp[i])
        return res