1. 题目一
给出题目一的试题链接如下:
1. 解题思路
这一题思路就是remove掉string最后的0
,这个用python的rstrip
函数就是一行代码的事,倒是不用过多赘述。
2. 代码实现
给出python代码实现如下:
class Solution:
def removeTrailingZeros(self, num: str) -> str:
return num.rstrip("0")
提交代码评测得到:耗时52ms,占用内存16.5MB。
2. 题目二
给出题目二的试题链接如下:
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. 题目三
给出题目三的试题链接如下:
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. 题目四
给出题目四的试题链接如下:
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))
提交代码评测得到:耗时7044ms,占用内存101.1MB。