leetcode第 211 场周赛

最新推荐文章于 2022-09-17 13:02:33 发布

AI驿站

最新推荐文章于 2022-09-17 13:02:33 发布

阅读量139

点赞数

分类专栏： leetcode

本文链接：https://blog.csdn.net/daniellibin/article/details/109149474

版权

leetcode 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

两个相同字符之间的最长子字符串


class Solution:
    def maxLengthBetweenEqualCharacters(self, s: str) -> int:
        dic = defaultdict(list)
        for i in range(len(s)):
            dic[s[i]].append(i)
        
        res = -1
        for k in dic.keys():
            if dic[k][-1] - dic[k][0] -1  > res:
                res = dic[k][-1] - dic[k][0] - 1 
        
        return res

执行操作后字典序最小的字符串

class Solution:
    def findLexSmallestString(self, s: str, a: int, b: int) -> str:
        s = list(s)
        res = s
        for i in range(len(s)):
            #  轮转
            s = s[-b:] + s[:len(s)-b]
            # 修改奇数位置
            for _ in range(10):
                for j in range(1,len(s),2):
                    s[j] = str(int(s[j]) + a)[-1]
                if b % 2 == 1:
                    #  b为奇数，此时通过轮转，也能修改偶数位置
                    for __ in range(10):
                        for k in range(0,len(s),2):
                            s[k] = str(int(s[k]) + a)[-1]                    
                        res = min(res, s)[::] # 深拷贝
                else:
                    res = min(res,s)[::] # 深拷贝
        
        return "".join(res)

无矛盾的最佳球队

经典贪心dp问题

维护一个二维数组mp，存储每个球员年龄以及和所得的分数。
1. 将数组排序，以便后续贪心，排序后年龄小的优先在前，年龄相同则分值小的在前。（排序是为了快速找到转移过来的选择）
2. 维护一个一维数组dp记录从0到i中，dp[i]表示选取下标i结尾的球员所能拿到的最大分数。
3. 开始贪心，对于下标i，从下标i-1开始往前寻找前一个适应球员，并更新最大值，遍历完最后再加上下标i球员的得分。（由于已经排序，就不需要再比较年龄）
4. 每次确定dp[i]的值后，如果dp[i] > maxs，则更新maxs，最后返回最大值maxs

在这里插入图片描述


class Solution:
    def bestTeamScore(self, scores: List[int], ages: List[int]) -> int:
        tmp = [] # 存储球员年龄以及分数
        for i in range(len(scores)):
            tmp.append((ages[i], scores[i]))
   
        tmp = sorted(tmp) # 对球员排序
        dp = [0] * len(tmp)
        maxScore = 0
        for i in range(len(tmp)):
            for j in range(i):
                if tmp[j][1] <= tmp[i][1]:
                    dp[i] = max(dp[i],dp[j])  # 查找前一个球员
            
            dp[i] += tmp[i][1]   # 加上以i结尾球员的分值
            maxScore = max(maxScore,dp[i])  # 更新最大值
         
        return maxScore

带阈值的图连通性

class Solution:
    def areConnected(self, n: int, threshold: int, queries: List[List[int]]) -> List[bool]:      
        parent=[i for i in range(n+1)]        
        
        def find(x):
            if x!=parent[x]:
                parent[x]=find(parent[x])
            return parent[x]
        
        def union(x,y):
            u=find(x)
            v=find(y)
            if u==v:
                return True
            parent[v]=u
            return False
        
        for i in range(threshold+1,n+1):
            for j in range(i*2,n+1,i):
                union(i,j)
        
        res=[]
        for u,v in queries:
            res.append(find(u)==find(v))
        return res