LeetCode笔记：Weekly Contest 347

Espresso Macchiato

于 2023-05-28 19:34:01 发布

阅读量742

点赞数

分类专栏： leetcode笔记文章标签：力扣周赛 347 leetcode 2710 leetcode 2711 leetcode 2712 leetcode 2713

本文链接：https://blog.csdn.net/codename_cys/article/details/130916374

版权

leetcode笔记专栏收录该内容

479 篇文章 4 订阅

订阅专栏

LeetCode笔记：Weekly Contest 347

比赛链接：https://leetcode.com/contest/weekly-contest-347/

1. 题目一

给出题目一的试题链接如下：

2710. Remove Trailing Zeros From a String

1. 解题思路

这一题思路就是remove掉string最后的0，这个用python的rstrip函数就是一行代码的事，倒是不用过多赘述。

2. 代码实现

给出python代码实现如下：

class Solution:
    def removeTrailingZeros(self, num: str) -> str:
        return num.rstrip("0")

提交代码评测得到：耗时52ms，占用内存16.5MB。

2. 题目二

给出题目二的试题链接如下：

2711. Difference of Number of Distinct Values on Diagonals

1. 解题思路

这一题其实也没啥难度，把题目意思翻译一下，然后用一个三重循环就行了。

2. 代码实现

给出python代码实现如下：

class Solution:
    def differenceOfDistinctValues(self, grid: List[List[int]]) -> List[List[int]]:
        n, m = len(grid), len(grid[0])
        res = [[0 for _ in range(m)] for _ in range(n)]
        for i in range(n):
            for j in range(m):
                k = 1
                s = set()
                while i+k < n and j+k < m:
                    s.add(grid[i+k][j+k])
                    k += 1
                rightbottom = len(s)
                
                k = 1
                s = set()
                while i-k >= 0 and j-k >= 0:
                    s.add(grid[i-k][j-k])
                    k += 1
                topleft = len(s)
                res[i][j] = abs(topleft - rightbottom)
        return res

提交代码评测得到：耗时312ms，占用内存16.7MB。

3. 题目三

给出题目三的试题链接如下：

2712. Minimum Cost to Make All Characters Equal

1. 解题思路

这一题思路上就是一个动态规划。

我们分别从左到右以及从右到左考察将所有字符全部变为0和全部变为1时的cost，然后取最小值即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def minimumCost(self, s: str) -> int:
        n = len(s)
        lzero = [0 for _ in range(n)]
        lones = [0 for _ in range(n)]
        rzero = [0 for _ in range(n)]
        rones = [0 for _ in range(n)]
        
        for i, ch in enumerate(s):
            if i == 0:
                if ch == '0':
                    lones[i] = 1
                else:
                    lzero[i] = 1
            else:
                if ch == '0':
                    lzero[i] = min(lzero[i-1], i + lones[i-1])
                    lones[i] = min(lzero[i]+i+1, 2*i+1 + lones[i-1])
                else:
                    lones[i] = min(lones[i-1], i + lzero[i-1])
                    lzero[i] = min(lones[i]+i+1, 2*i+1 + lzero[i-1])
                    
        for i, ch in enumerate(s[::-1]):
            if i == 0:
                if ch == '0':
                    rones[i] = 1
                else:
                    rzero[i] = 1
            else:
                if ch == '0':
                    rzero[i] = min(rzero[i-1], i + rones[i-1])
                    rones[i] = min(rzero[i]+i+1, 2*i+1 + rones[i-1])
                else:
                    rones[i] = min(rones[i-1], i + rzero[i-1])
                    rzero[i] = min(rones[i]+i+1, 2*i+1 + rzero[i-1])
        return min(min(lzero[i] + rzero[n-1-i] for i in range(n)), min(lones[i] + rones[n-1-i] for i in range(n)))

提交代码评测得到：耗时1678ms，占用内存28.4MB。

3. 算法优化

看了一下其他大佬们的解答，发现还是想复杂了……

class Solution:
    def minimumCost(self, s: str) -> int:
        ans = 0 
        for i, ch in enumerate(s): 
            if i and s[i-1] != ch: 
                ans += min(i, len(s)-i)
        return ans

果然还是没有想明白本质啊……

4. 题目四

给出题目四的试题链接如下：

2713. Maximum Strictly Increasing Cells in a Matrix

1. 解题思路

这一题思路上同样就是一个动态规划。

显然，最大的那个元素位置上的答案为1。

然后，我们倒序找回去，任何一个位置作为起始点能够走的步数一定是其所在的行或者列上下一个较大的值作为起始点时能够走的步数加一。

因此，有了这个迭代关系，我们用一个动态规划算法就能很快得到我们的答案了。

2. 代码实现

给出python代码实现如下：

class Solution:
    def maxIncreasingCells(self, mat: List[List[int]]) -> int:
        n, m = len(mat), len(mat[0])
        
        rows = [[(math.inf, 0)] for _ in range(n)]
        cols = [[(math.inf, 0)] for _ in range(m)]
        
        res = [[1 for _ in range(m)] for _ in range(n)]
        vals = sorted([[mat[i][j], i, j] for i in range(n) for j in range(m)], reverse=True)
        for v, i, j in vals:
            c = bisect.bisect_left(rows[i], (v, 0))
            r = bisect.bisect_left(cols[j], (v, 0))
            res[i][j] = 1 + max(-rows[i][c][1], -cols[j][r][1])
            bisect.insort(rows[i], (v, -res[i][j]))
            bisect.insort(cols[j], (v, -res[i][j]))
        return max(res[i][j] for i in range(n) for j in range(m))