Leetcode 周赛 194

https://leetcode-cn.com/contest/weekly-contest-194/

周赛地址↑

数组异或操作

'''
按照题意即可
'''
class Solution:
    def xorOperation(self, n: int, start: int) -> int:
    	ans=0
    	for i in range(n):
    		ans^=(n*2+start)
    	return ans

1487. 保证文件名唯一

'''
同样按照题意即可
'''
class Solution:
    def getFolderNames(self, names: List[str]) -> List[str]:
        visited={}
        res=[]
        for ch in names:
            if ch not in visited:
                visited[ch]=1
                res.append(ch)
            else:
                k=visited[ch] 
                '''
                标记k的原因是有如 kkk,kkk,kkk(很多个，方便直接定位到最新一个)
                '''
                name=ch+'('+str(k)+')'
                while name in visited:
                    name=ch+'('+str(k)+')'
                    k+=1
                res.append(name)
                visited[ch]=k
                visited[name]=1
                '''
                两个都要更新
                '''
        return res

1488. 避免洪水泛滥

思路：两边遍历，第一遍遍历获取所有池塘下雨的信息
第二遍遍历生成解答数组 具体看代码：

class Solution:
    def avoidFlood(self, rains: List[int]) -> List[int]:
        count=collections.defaultdict(list)#各个池塘要下雨的时间
        p=collections.defaultdict(int)#池塘下了第几次雨
        zerocnt=0#晴天计数
        floocnt=0#会发生洪水的天数计数
        for i,ni in enumerate(rains):
            if ni and count[ni]:
                floacnt+=1
            if not ni:
                zerocnt+=1
            if zerocnt<floacnt:
                return []#不能够按时抽干池塘，一定会发生洪水
            count[ni].append(i)
        
        res=[]#返回列表
        queue=[]#优先队列
        flooting=set()#已经满溢的池塘
        for i,ni in enumerate(rains):
            if ni :
            '''
            如果雨天，返回数组先加入-1
            如果有下一次洪水就入队下一次下雨的日期
            如果此时池塘已经满了，就返回[]
            '''
                res.append(-1)
                if len(count[ni])>1:
                    if ni in floating:
                        return []
                    floating.add(ni)
                    if p[ni]<len(count[ni])-1:
                        heapq.heappush(queue,count[ni][p[ni]+1])
                        p[ni]+=1
            else:
            '''
            如果晴天，且优先队列不空
            就抽干最优先的池塘（最先下雨的池塘）
            如果队列空，就抽干第一个池塘（题目无要求抽干哪一个池塘，但是一定会有1号池塘）
            '''
                if queue:
                    poi=heapq.heappop(queue)
                    res.append(rains[poi])
                    floating.discard(rains[poi])
                else:
                    res.append(1)
        return res

1489. 找到最小生成树里的关键边和伪关键边

思路 利用kruskal算法得到最小生成树的权值和
题目中关键边的定义就是去掉该边权值和上升
非关键边就是去掉该边权值和不变 直接带入即可

class Solution:
   def findCriticalAndPseudoCriticalEdges(self, n: int, edges: List[List[int]]) -> List[List[int]]:
       index=[i for i in range(len(edges))]
       index.sort(key=lambda x:edges[x][2])
       edges=[edges[i] for i in index]#建立边与序号的映射关系
       min_cost=self.kruskal(n,edges)#树中每一条边都加入，找最小生成树
       res=[[],[]]
       for i in range(len(edges)):
           notadd=edges[i]#去掉的边
           nedges=edges[:i]+edges[i+1:]#剩余的边的合集
           if self.kruskal(n,nedges)>min_cost:#关键边
               res[0].append(index[i])
           elif self.kruskal(n,nedges,notadd)==min_cost:#非关键边
               res[1].append(index[i])
       return res
   def kruskal(self,n,edges,preadd=None):#很基本的kruskal算法
       ori=[i for i in range(n)]
       def find(x):
           if ori[x]!=x:
               ori[x]=find(ori[x])
           return ori[x]
       cost=edgecnt=0
       if preadd:#提前加入的边
           v1,v2,price=preadd
           cost=price
           edgecnt=1
           ori[find(v2)]=find(v1)
       for v1,v2,p in edges:
           if find(v1)==find(v2):
               continue
           cost+=p
           edgecnt+=1
           ori[find(v2)]=find(v1)
           if edgecnt==n-1:
               break
       
       return cost if edgecnt==n-1 else float('inf')#小心 可能不会成树