leetcode 第 308 场周赛

---

和有限的最长子序列

数组排序后，计算前缀和
之后每次查询寻找小于等于查询值的最大序号，可以使用二分加速查询

from collections import Counter
class Solution:
    def answerQueries(self, nums: List[int], queries: List[int]) -> List[int]:
        res =[ ]
        nums = sorted(nums)
        for i in range(1,len(nums)):
            nums[i]+=nums[i-1]
        for q in queries:
            pos=0
            while pos<len(nums) and nums[pos]<=q:
                pos+=1
            if nums[pos-1]>q:
                res.append(0)
            else:
                res.append(pos)
        return res

---

从字符串中移除星号

类似栈的简单构造，当遇到‘*’号时弹出一个字符

class Solution:
    def removeStars(self, s: str) -> str:
        res=[]
        for i in range(len(s)):
            if s[i]=='*':
                res.pop()
            else:
                res.append(s[i])
        return ''.join(res)

---

收集垃圾的最少总时间

虽然说是计算最少总时间，其实直接遍历一遍即可
但要记住，如果后续没有该垃圾车需要清理的垃圾，就不用前往下一个地点
同时，每个地点垃圾处理时间其实是字符串的长度

class Solution:
    def garbageCollection(self, garbage: List[str], travel: List[int]) -> int:
        res = len(garbage[0])
     
        t1,t2,t3=0,0,0
       
        for i in range(1,len(garbage)):
            tar = garbage[i]
            res+=len(tar)
            t1+=travel[i-1]
            t2+=travel[i-1]
            t3+=travel[i-1]
            if 'M' in tar:
                res+=t1
                t1=0
            if 'P' in tar:
                res+=t2
                t2=0
            if 'G' in tar:
                res+=t3
                t3=0
        return res

---

给定条件下构造矩阵

该题目存在明显的点与点之间的依赖关系，所以考虑用拓扑排序构造边解决，
对rowConditions，colConditions两个数组生成各自的拓扑排序
后根据值所在的序号进行矩阵填充即可

from collections import defaultdict
class Solution:
    def buildMatrix(self, k: int, rowConditions: List[List[int]], colConditions: List[List[int]]) -> List[List[int]]:
        res1,res2=[],[]
      
        deg1,deg2=defaultdict(int),defaultdict(int)
        out1,out2=defaultdict(list),defaultdict(list)
        for i in range(1,k+1): 
            deg1[i],deg2[i]=0,0

        for row in rowConditions: 
            if row[1] not in out1[row[0]]:
                deg1[row[1]]+=1
                out1[row[0]].append(row[1])
        for col in colConditions: 
            if col[1] not in out2[col[0]]:
                deg2[col[1]]+=1
                out2[col[0]].append(col[1])

   
        def fun(item,deg,out):
            q=[k for k,v in deg.items() if v==0]
            # print(q)
            temp=[]
            cnt=0
            while q:
                tar=q.pop()
                temp.append(tar)
                cnt+=1
                
                for o in out[tar]:
                    deg[o]-=1
                    if deg[o]==0:
                        q.append(o)
            
            return temp if cnt==k else []
           
        res1=fun(rowConditions,deg1,out1)
        res2=fun(colConditions,deg2,out2)
  
        if len(res1)==0 or len(res2)==0:
            return []

        res=[[0]*k for _ in range(k)]
        pos=[[0,0]for _ in range(k+1)]
        
        for step,r in enumerate(res1):
            pos[r][0]=step
        for step,r in enumerate(res2):
            pos[r][1]=step

        for i in range(1,k+1):
            res[pos[i][0]][pos[i][1]]=i
        return res

不过虽然我想到了，但代码却debug了好久，
诶，代码能力还是有待提高

---

总结

orz，不过这次周赛题目确实简单