力扣284场单周赛-python

这次周赛的成绩是有史以来最好的一次，其实这不是最让我高兴的。
周赛做出了三道题，前两道还行，第三道没有思路，直接看第四道，第四道是最短路有关的问题，一看就是迪杰斯特拉最短路问题，利用反向建图求出终点到所有点的最短路，即多源单点最短路，然后两个起点的单源最短路。
当我看到数据范围时，如果使用朴素的dijkstra最短路，这是一定会超时的，所以一定要用二叉堆来优化，而二叉堆的优化问题以及二叉堆的实现，我在昨天的博客中就已经介绍了，并且完成了，所以正好用上了，这是让我十分意外的。

周赛代码

#1
class Solution:
    def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
        lth=len(nums)
        ans=[]
        index=0
        vis=[0]*lth
        while index<lth:
            if nums[index]==key:
                for i in range(max(0,index-k),min(index+k+1,lth)):
                    if not vis[i]:
                        vis[i]=1
                        ans.append(i)
            index+=1
        return ans
    

2
class Solution:
    def digArtifacts(self, n: int, artifacts: List[List[int]], dig: List[List[int]]) -> int:
        tag=[[0 for i in range(n)] for j in range(n)]
        lth1=len(dig)
        for i in range(lth1):
            r,c=dig[i][0],dig[i][1]
            tag[r][c]=1
            
        ans=0
        lth2=len(artifacts)
        for i in range(lth2):
            flag=1
            r1,c1,r2,c2=artifacts[i][0],artifacts[i][1],artifacts[i][2],artifacts[i][3]
            for x in range(r1,r2+1):
                for y in range(c1,c2+1):
                    if tag[x][y]==0:
                        flag=0
                        break
            if flag:
                ans+=1
        return ans

4
class node:
    def __init__(self,val,idx):
        self.val=val
        self.idx=idx
class heap:
    arr=[]
    def __init__(self,s=None):
        if s!=None:
            self.arr.append(s)
        
    def change(self,x,y):
        self.arr[x].val,self.arr[y].val=self.arr[y].val,self.arr[x].val

        self.arr[x].idx,self.arr[y].idx=self.arr[y].idx,self.arr[x].idx
    
    def maintain(self,idx):
        size=self.get_size()
        left=2*idx+1
        right=2*idx+2

        small=idx
        if left<size and self.arr[left].val<self.arr[idx].val:
            small=left
        else:
            small=idx
        if right<size and self.arr[right].val<self.arr[small].val:
            small=right
        if small!=idx:
            self.change(idx,small)
            self.maintain(small)
            
    def push(self,tmp):
        self.arr.append(tmp)
        #向上维护堆
        son=self.get_size()-1
        
        father=(son-1)//2
        while son!=0 and self.arr[son].val<self.arr[father].val:
            self.change(father,son)
            son=father
            father=(son-1)//2
        
    def pop(self):
        #最后一个元素上堆顶 向下维护堆
        #注意这里是列表 不能直接返回第一个元素 应当返回第一个元素的索引 这样就不是引用了
        tmp=self.arr[0].idx
        
        son=self.get_size()-1
        self.change(0,son)
        self.arr.pop()
        self.maintain(0)

        return tmp
    def is_empty(self):
        return len(self.arr)==0
    
    def get_size(self):
        return len(self.arr)
class Solution:
    def minimumWeight(self, n: int, edges: List[List[int]], src1: int, src2: int, dest: int) -> int:
        point=[[] for _ in range(n)]
        lth=len(edges)
        for i in range(lth):
            v=edges[i][1]
            point[v].append(i)
        hp=heap()
        dis=[float("inf") for i in range(n)]
        vis=[0 for i in range(n)]
        def dijkstra(sta):
            dis[sta]=0
            hp.push(node(0,sta))
            while not hp.is_empty():
                tmp=hp.pop()
                if vis[tmp]:
                    continue
                vis[tmp]=True
                size=len(point[tmp])
                for i in range(size):
                    v,w=edges[point[tmp][i]][0],edges[point[tmp][i]][2]
                    if not vis[v] and dis[v]>dis[tmp]+w:
                        dis[v]=dis[tmp]+w
                        hp.push(node(dis[v],v))
        def dijkstra2(sta):
            nhp=heap()
            ndis=[float("inf") for i in range(n)]
            nvis=[0 for i in range(n)]
            lth=len(edges)
            npoint=[[] for _ in range(n)]
            for i in range(lth):
                u=edges[i][0]
                npoint[u].append(i)
            ndis[sta]=0
            nhp.push(node(0,sta))
            while not nhp.is_empty():
                tmp=nhp.pop()
                if nvis[tmp]:
                    continue
                nvis[tmp]=True
                size=len(npoint[tmp])
                for i in range(size):
                    v,w=edges[npoint[tmp][i]][1],edges[npoint[tmp][i]][2]
                    if not nvis[v] and ndis[v]>ndis[tmp]+w:
                        ndis[v]=ndis[tmp]+w
                        nhp.push(node(ndis[v],v))
            return ndis
        dijkstra(dest)
        if dis[src1]==float("inf") or dis[src2]==float("inf"):
            return -1
        else:
            ndis1=dijkstra2(src1)
            ndis2=dijkstra2(src2)
            ans=float("inf")
            for i in range(n):
                if dis[i]!=float("inf"):
                    if ndis1[i]+ndis2[i]+dis[i]<ans:
                        ans=ndis1[i]+ndis2[i]+dis[i]
            return ans    

下次双周赛加油！