add files

Author: aaron.liu

Graph/LC1443MinimumTimeToCollectAllApplesInATree.py

@@ -0,0 +1,27 @@
+
+'''
+
+'''
+from typing import List
+import collections
+
+
+class Solution:
+    def minTime(self, n: int, edges: List[List[int]], hasApple: List[bool]) -> int:
+        adjList = collections.defaultdict(list)
+        for edge in edges:
+            adjList[edge[0]].append(edge[1])
+            adjList[edge[1]].append(edge[0])
+        visited = set()
+        return self.dfs(0, adjList, visited, hasApple) * 2
+    
+    def dfs(self, cur_node: int, graph: dict[int, List[int]], visited: set[int], hasApple: List[bool]) -> int:
+        step = 0
+        for nbr in graph[cur_node]:
+            if not nbr in visited:
+                visited.add(cur_node)
+                step += self.dfs(nbr, graph, visited, hasApple)
+                visited.remove(cur_node)
+        if (hasApple[cur_node] or step != 0) and cur_node != 0:
+            step += 1
+        return step

Memo/LC2060CheckIfAnOriginalStringExistsGivenTwoEncodedStrings.py

@@ -0,0 +1,10 @@
+
+'''
+
+'''
+from typing import List
+import collections
+
+class Solution:
+    def possiblyEquals(self, s1: str, s2: str) -> bool:
+        pass

Stack/LC42TrappingRainWater.py

@@ -0,0 +1,20 @@
+from typing import List
+
+class Solution:
+    def trap(self, height: List[int]) -> int:
+        stk = []
+        ret = 0
+
+        for i in range(len(height)):
+            while stk and height[stk[-1]] <= height[i]:
+                top = stk[-1]
+                stk.pop()
+                
+                if not stk:
+                    break
+                
+                ret += (i - stk[-1] - 1) * (min(height[i], height[stk[-1]]) - height[top])
+            
+            stk.append(i)
+            
+        return ret

Stack/LC716MaxStack.py

@@ -0,0 +1,49 @@
+from collections import OrderedDict
+
+class Node:
+    def __init__(self, val=None, next=None, prev=None):
+        self.val = val
+        self.next = next
+        self.prev = prev
+
+class MaxStack:
+
+    def __init__(self):
+        self.orderedDict = OrderedDict()                # int_val -> list of Nodes with same int val
+        self.tailNode = Node()
+        self.headNode = Node()
+        self.tailNode.next = self.headNode
+        self.headNode.prev = self.tailNode
+
+    def push(self, x: int) -> None:
+        curNode = Node(x)
+        self.headNode.prev.next = curNode
+        curNode.next = self.headNode
+        curNode.prev = self.headNode.prev
+        self.headNode.prev = curNode
+
+        if x in self.orderedDict:
+            self.orderedDict[x].append(curNode)
+        else:
+            self.orderedDict[x] = [curNode]
+
+    def pop(self) -> int:
+        pass
+
+    def top(self) -> int:
+        pass
+
+    def peekMax(self) -> int:
+        pass
+
+    def popMax(self) -> int:
+        pass
+
+
+# Your MaxStack object will be instantiated and called as such:
+# obj = MaxStack()
+# obj.push(x)
+# param_2 = obj.pop()
+# param_3 = obj.top()
+# param_4 = obj.peekMax()
+# param_5 = obj.popMax()

Stack/LC84LargestRectangleInHistogram.py

@@ -0,0 +1,17 @@
+from typing import List
+class Solution:
+    def largestRectangleArea(self, heights: List[int]) -> int:
+        ret = 0
+        stk = []
+        heights.append(-1)
+
+        for i in range(len(heights)):
+            while stk and heights[stk[-1]] > heights[i]:
+                top = stk.pop()
+                if not stk:
+                    ret = max(ret, heights[top] * i)
+                else:
+                    ret = max(ret, heights[top] * (i - stk[-1] - 1))
+            stk.append(i)        
+        
+        return ret

TwoPointers/LC347TopKFrequentElements.py

@@ -0,0 +1,32 @@
+import collections
+from typing import List
+
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        if not nums: return []
+        self.counter = collections.Counter(nums)
+        keys = list(self.counter.keys())
+        idx = self.partition(keys, k, 0, len(keys)-1)
+        return keys[:idx+1]
+    
+    def partition(self, keys, k, start, end) -> int:
+        if start >= end:                                # corner case: keys is empty. start = 0, end = -1
+            return start
+        left, right = start - 1, end + 1
+        
+        pivot = self.counter[keys[(left + right) // 2]]
+        while left < right:
+            while True:
+                left += 1
+                if self.counter[keys[left]] <= pivot:
+                    break
+            while True:
+                right  -= 1
+                if self.counter[keys[right]] >= pivot:
+                    break
+            if left < right:
+                keys[left], keys[right] = keys[right], keys[left]
+        if k <= right - start + 1:
+            return self.partition(keys, k, start, right)
+        else:
+            return self.partition(keys, k - (right - start + 1), right + 1, end)

TwoPointers/LC42TrappingRainWater.py

@@ -1,4 +1,4 @@
- '''
+'''
  复杂度
  时间 O(n) 空间(1)
  思路：双指针->相遇问题