自娱自乐的精神乐园

余凯迪的博客

0%

leetcode_biweekly_contest_26

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

5396. 连续字符

思路：
用单独的变量记录前一个字符，判断当前字符和前一个字符是否相同，以此来进行计数。

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

5397. 最简分数

思路：
比较简单，依次遍历2到n，找到其对应的所有互质的数。

1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution:
    def gcd(self,a,b):
        # 欧几里得算法求最大公约数
        return a if b==0 else self.gcd(b,a%b)
    
    def simplifiedFractions(self, n: int) -> List[str]:
        res = []
        for x in range(2,n+1):
            res.append("1/%d"%x)
            for i in range(2,x):
                if self.gcd(i,x) == 1:
                    res.append("%d/%d" % (i,x))
        return res

5398. 统计二叉树中好节点的数目

思路：
深度优先搜索的时候，将路径上遇到的最大值依次往下传递即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def __init__(self):
        # 记录结果
        self.res = 0
    
    def dfs(self, root, max_num):
        if root is None:
            return 0
        max_num  = max(max_num, root.val)
        if root.val >= max_num:
            self.res += 1
        self.dfs(root.left, max_num)
        self.dfs(root.right, max_num)
        
    def goodNodes(self, root: TreeNode) -> int:
        if root is None:
            return 0
        self.dfs(root, root.val)
        return self.res

5399. 数位成本和为目标值的最大数字

思路：
给定cost数组， 对target分解进行求解，很明显的搜索或者DP的思路。

  1. 对于cost相同的数字，只需要记录最大的那个即可。
  2. 对于给定的cost数组，任意target的方案的最大值是唯一的；深度优先搜索的时候，可以利用哈希记录不同target对应的值，及时终止递归。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class Solution:
    def dfs(self, target):
        if target in self.mm:
            return self.mm[target]
        if target < 0:
            # 返回0意味着target没有成功进行拆分
            return 0
        max_res =  0
        for key, val in self.cost_map.items():
            if target == key:
                max_res = max(val, max_res)
                continue
            tmp = val
            tmp_res = self.dfs(target-key)
            if tmp_res != 0:
                max_res = max(int(str(tmp)+str(tmp_res)), max_res)
                max_res = max(int(str(tmp_res)+str(tmp)), max_res)
        self.mm[target] = max_res
        return max_res
    
    def largestNumber(self, cost: List[int], target: int) -> str:
        self.cost_map = {}
        self.mm = {}
        for i,x in enumerate(cost):
            if x in self.cost_map:
                self.cost_map[x] = max(i+1, self.cost_map[x])
            else:
                self.cost_map[x] = i+1
        print(self.cost_map)
        res = self.dfs(target)
        return str(res)