Update

Author: lkwq007

Diff for: 1096-Brace-Expansion-II.py

@@ -0,0 +1,39 @@
+class Solution:
+    def braceExpansionII(self, expression: str) -> List[str]:
+        self.idx=0
+        def eat_word():
+            start=self.idx
+            while self.idx<len(expression) and expression[self.idx].isalpha():
+                self.idx+=1
+            return expression[start:self.idx]
+        def parse():
+            lst=[""]
+            ret=set([])
+            while self.idx<len(expression):
+                item=expression[self.idx]
+                if item=="{":
+                    self.idx+=1
+                    tmp=parse()
+                    new_lst=[]
+                    for a in lst:
+                        for b in tmp:
+                            new_lst.append(a+b)
+                    lst=new_lst
+                elif item=="}":
+                    self.idx+=1
+                    break
+                elif item==",":
+                    self.idx+=1
+                    for item in lst:
+                        ret.add(item)
+                    lst=[""]
+                else:
+                    word=eat_word()
+                    for i in range(len(lst)):
+                        lst[i]+=word
+            if len(lst)>1 or lst[0]!="":
+                for item in lst:
+                    ret.add(item)
+            return ret
+        ret=parse()
+        return list(sorted(ret))

Diff for: 1263-Minimum-Moves-to-Move-a-Box-to-Thei.py

@@ -11,8 +11,11 @@ def minPushBox(self, grid: List[List[str]]) -> int:
         # first check
         template=[-1]*w
         visited=[template[:] for _ in range(h)]
+        tin=[template[:] for _ in range(h)]
+        low=[template[:] for _ in range(h)]
         direction=[(1,0),(0,1),(-1,0),(0,-1)]
-        def dfs(y0,x0,target):
+        last=[]
+        def check(y0,x0,target):
             tmp=visited[y0][x0]
             visited[y0][x0]=-2
             flag=False
@@ -21,21 +24,48 @@ def dfs(y0,x0,target):
                 x1=x0+x_offset
                 if 0<=y1<h and 0<=x1<w and grid[y1][x1]!="#":
                     if grid[y1][x1]==target:
+                        last.append((y0,x0))
+                        flag=True
+                        break
+                    elif visited[y1][x1]!=-2 and check(y1,x1,target):
                         flag=True
                         break
-                    elif visited[y1][x1]!=-2:
-                        if dfs(y1,x1,target):
-                            flag=True
-                            break
             visited[y0][x0]=tmp
             return flag
-        if not (dfs(player[0],player[1],"B") and dfs(box[0],box[1],"T")):
+        if not (check(player[0],player[1],"B") and check(box[0],box[1],"T")):
             return -1
+        articulation={}
+        self.timer=1
+        def dfs(y0,x0,yp,xp):
+            tin[y0][x0]=self.timer
+            low[y0][x0]=self.timer
+            self.timer+=1
+            cnt=0
+            for y_offset,x_offset in direction:
+                y1=y0+y_offset
+                x1=x0+x_offset
+                if 0<=y1<h and 0<=x1<w and grid[y1][x1]!="#":
+                    if yp==y1 and xp==x1:
+                        continue
+                    elif tin[y1][x1]!=-1:
+                        low[y0][x0]=min(low[y0][x0],tin[y1][x1])
+                    else:
+                        cnt+=1
+                        dfs(y1,x1,y0,x0)
+                        low[y0][x0]=min(low[y0][x0],low[y1][x1])
+                        if low[y1][x1]>=tin[y1][x1] and yp!=-1:
+                            articulation[(y0,x0)]=1
+            if yp==-1 and cnt>1:
+                articulation[(y0,x0)]=1
+        for y in range(h):
+            for x in range(w):
+                if tin[y][x]==-1:
+                    dfs(y,x,-1,-1)
+        queue=[(*box,*(last[0]))]
         visited[box[0]][box[1]]=0
         step=0
-        queue=[box]
         while queue:
             target=[]
-            for y0,x0 in queue:
-                
-        return -1
+            step+=1
+            for y0,x0,ys,xs in queue:
+                

Diff for: 888-Fair-Candy-Swap.py

@@ -0,0 +1,11 @@
+class Solution:
+    def fairCandySwap(self, A: List[int], B: List[int]) -> List[int]:
+        a=sum(A)
+        b=sum(B)
+        diff=(a-b)//2
+        record={}
+        for item in B:
+            record[item]=1
+        for item in A:
+            if item-diff in record:
+                return [item,item-diff]

Diff for: 954-Array-of-Doubled-Pairs.py

@@ -0,0 +1,38 @@
+class Solution:
+    def canReorderDoubled(self, A: List[int]) -> bool:
+        record={}
+        for item in A:
+            record[item]=record.get(item,0)+1
+        if record.get(0,0)%2==1:
+            return False
+        elif 0 in record:
+            del record[0]
+        last=len(record)+1
+        while last!=len(record):
+            last=len(record)
+            for key in list(record.keys()):
+                if key not in record:
+                    continue
+                if key%2!=0:
+                    if record.get(key*2,0)<record[key]:
+                        return False
+                    record[key*2]-=record[key]
+                    if record[key*2]==0:
+                        del record[key*2]
+                    del record[key]
+                else:
+                    half=record.get(key//2,0)
+                    double=record.get(key*2,0)
+                    if half+double<record[key]:
+                        return False
+                    if half==0:
+                        record[key*2]-=record[key]
+                        if record[key*2]==0:
+                            del record[key*2]
+                        del record[key]
+                    elif double==0:
+                        record[key//2]-=record[key]
+                        if record[key//2]==0:
+                            del record[key//2]
+                        del record[key]
+        return len(record)==0