update

Author: aaron.liu

BFS/LC210 Course Schedule II.py

@@ -0,0 +1,21 @@
+'''
+https://leetcode.com/problems/course-schedule-ii/description/
+返回任意一个拓扑序列 可以用bfs解决
+注意: 有向无环图才有拓扑序 有环图一定没有拓扑序
+算法框架:
+a. 将图中所有入度为零的点入队列  
+queue <-- all nodes with in-degree 0
+b. 
+while queue is not not empty:
+  t <- q.front()
+  枚举t的所有出边 t <-- j
+  删掉出边t->j 并将j的入度减一: in_degree[j] -= 1
+  如果in_degree[j] == 0: 将j点入队列 queue <- j
+最后队列中的元素顺序 就是一个拓扑序
+'''
+import collections
+from typing import List
+
+class Solution:
+    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
+        graph = collections.defaultdict(list)

BFS/LC317 Shortest Distance from All Buildings.py

@@ -4,9 +4,33 @@
 '''
 
 from typing import List
+from collections import deque
 from collections import defaultdict
 
 class Solution:
     def shortestDistance(self, grid: List[List[int]]) -> int:
         m, n = len(grid), len(grid[0])
-        dist, k = defaultdict(int), 0
+        dist, cnt = defaultdict(int), 0
+        for i in range(m):
+            for j in range(n):
+                if grid[i][j] == 1:
+                    self.bfs(grid, m, n, i, j, cnt, dist)
+                    cnt += 1
+        min_dist = float("inf")
+        for (x, y), step in dist.items():
+            if grid[x][y] == -cnt:
+                min_dist = min(min_dist, step)
+        return min_dist if min_dist != float("inf") else -1
+
+    def bfs(self, grid, m, n, i, j, cnt, dist):
+        directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
+        queue = deque([(0, i, j)])
+        while queue:
+            step, x, y = queue.popleft()
+            step += 1
+            for dx, dy in directions:
+                nx, ny = x + dx, y + dy
+                if 0 <= nx < m and 0 <= ny < n and grid[nx][ny] == -cnt:
+                    queue.append((step, nx, ny))
+                    grid[nx][ny] -= 1
+                    dist[(nx, ny)] += step

BinarySearch/LC528 Random Pick with Weight.py

@@ -0,0 +1,49 @@
+'''
+https://leetcode.com/problems/random-pick-with-weight/
+
+w:     [1, 2, 3]
+idx:    0  1  2
+随机返回一个下标 要求返回下标对应的权重 与总权重(每个权重相加)成正比
+先把w的值想象成一个个线段:
+ A  B    C 
+<-><--><--->
+  1   3    6
+A,B,C三个区间长度分别为1,2,3 (1,3,6)是区间总长度 
+假如现在有个[1,6]之间随机数 落在哪个区间上 就返回对应区间的下标即可
+比如落在B区间 返回B区间对应的下标1 就符合下标对应的权重与总权重成正比
+如何实现上述操作? 转化成整数二分+前缀和
+观察到:(1,3,6)这几个区间长度的尾端点 就是w的前缀和
+prefix sum: 0 1 2 3 4 5 6 (注意只有1,3,6是前缀和 其它数字写出来方便后续理解)
+区间:        <-><--><---->         
+区间编号:      A  B    C  
+w idx:        0   1    2
+
+问题转化为: 随机出一个[1,max_prefix_sum]之间的整数target 然后二分前缀和数组 
+找到第一个大于等于target的值 等价于找到了这个随机数落在了哪个长度的区间内
+二分找到的值 代表了所在区间长度的右端点 它的下标 也就是w原数组的下标  
+'''
+
+import random
+from typing import List
+
+class Solution:
+    def __init__(self, w: List[int]):
+        self.prefix_sum = [0] * len(w)
+        self.prefix_sum[0] = w[0]
+        for i in range(1, len(w)):
+            self.prefix_sum[i] = self.prefix_sum[i - 1] + w[i]
+    def pickIndex(self) -> int:
+        target = random.randint(1, self.prefix_sum[-1]) # 随机一个[1, max_prefix_sum]之间的整数
+        # 二分找第一个大于等于target的前缀和的值 并返回对应的下标
+        left, right = 0, len(self.prefix_sum) - 1
+        while left < right:
+            mid = (left + right) // 2
+            if self.prefix_sum[mid] < target: # mid对应的值比target小 一定不是答案 所以mid+1跳过mid
+                left = mid + 1
+            else:
+                right = mid # mid对应的值>=target 可能是答案 所以不能跳过mid
+        return left
+
+# Your Solution object will be instantiated and called as such:
+# obj = Solution(w)
+# param_1 = obj.pickIndex()

DFS/Uber all topo sort.py

@@ -0,0 +1,58 @@
+'''
+same set up as https://leetcode.com/problems/course-schedule-ii/
+it requries to return all topological sort
+1. 根据边与边的关系 建立有向图 注意边的指向
+2. 建图过程中 构建in_degree数组:in_degree[i]代表i号点的入度
+3. dfs找所有的path dfs过程如下
+a. 遍历所有的点 如果当前点x满足如下条件:
+    - 入度为0: in_degree[x] == 0
+    - 没有在当前的路径上遍历过 visited[x] == False
+    将该点放入探索路径上 tmp.append(x)
+b. 记录当前点x为visited 并把它的出边的所有入度都减1(in_degree[i] -= 1 for all x->i)
+c. 递归调用dfs
+d. dfs调用返回 还原所有状态:
+   - 还原x的出边点所有的入度(in_degree[i] += 1 for all x->i)
+   - 当前探索路径上删掉x: tmp.pop()
+   - 当前点x记录为un-visited
+
+Time Complexity: O(V!) V is the number of vertices, V! is absolute worst case. 
+(worst case example: any graph with no edges at all)
+Space: O(V) for creating an additional array and recursive stack space.
+'''
+from typing import List
+import collections
+
+def findOrder(numCourses: int, prerequisites: List[List[int]]) -> List[int]:
+    graph = collections.defaultdict(list)
+    in_degree = [0] * numCourses
+    res = []
+    visited = [False] * numCourses
+    for x, y in prerequisites:
+        graph[y].append(x)
+        in_degree[x] += 1
+    find_all_topo_orders(res, graph, in_degree, [], numCourses, visited)
+    return res
+
+def find_all_topo_orders(res, graph, in_degree, tmp, n, visited):
+    if len(tmp) == n:
+        print("found one:", tmp)
+        res.append(tmp[:])
+        return
+    
+    for vtx in range(n):
+        if in_degree[vtx] == 0 and not visited[vtx]:
+            visited[vtx] = True
+            tmp.append(vtx)
+            for nei in graph[vtx]:
+                in_degree[nei] -= 1
+            find_all_topo_orders(res, graph, in_degree, tmp, n, visited)
+            for nei in graph[vtx]:
+                in_degree[nei] += 1
+            tmp.pop()
+            visited[vtx] = False
+
+n = 4
+p = [[1,0], [2,0], [3,2], [3,1]]
+n = 3
+# p = [[1,0], [2,1], [0,2]]
+print(findOrder(n, p))

DP/LC213 House Robber II.py

@@ -0,0 +1,34 @@
+'''
+https://leetcode.com/problems/house-robber-ii/?envType=company&envId=apple&favoriteSlug=apple-three-months
+
+状态机dp
+'''
+from typing import List
+
+class Solution:
+    # 状态机dp
+    def rob(self, nums: List[int]) -> int:
+        if len(nums) == 1:
+            return nums[0]
+        size = len(nums)
+        # f[i][j] 第i号点 取(j==1)或者不取(j==0)
+        dp = [[0,0] for i in range(size + 1)]
+        # 枚举第1号点 取或者不取. 它决定了最后一个点是否能取
+        # 第1号点取 dp[1][0]这个状态就非法 赋值负无穷
+        dp[1][0] = -1e5
+        dp[1][1] = nums[0]
+        for i in range(2, size + 1):
+            dp[i][1] = dp[i - 1][0] + nums[i - 1]
+            dp[i][0] = max(dp[i - 1][1], dp[i - 1][0])
+        
+        ret = dp[size][0] # 第1号点取了 最后一个点只能不取
+        
+        # 第1号点不取 dp[1][1]状态非法 赋值负无穷
+        dp[1][1] = -1e5
+        dp[1][0] = 0  # 注意这里要对dp[1][0]重新赋值 上面的逻辑修改过dp[1][0]
+        for i in range(2, size + 1):
+            dp[i][1] = dp[i - 1][0] + nums[i - 1]
+            dp[i][0] = max(dp[i - 1][1], dp[i - 1][0])
+        
+        ret = max(ret, dp[size][1], dp[size][0])
+        return ret

MonoQueue/LC995 Minimum Number of K Consecutive Bit Flips.py

@@ -0,0 +1,29 @@
+'''
+(队列实现滑动窗口) O(n)
+首先我们可以知道，对于每个位置而言，只有初始状态和总共被反转了多少次决定了自己最终的状态。另一方面，我们知道每一个长度为K的区间，最多只会被反转一次，因为两次反转后对最终结果没有影响。基于此，我们从前往后遍历数组，如果遇到一个0，我们将当前位置开始的长度为k区间的区间反转。如果遇到0时，剩下的区间长度不足K说明我们没有办法完成反转。但是如果我们每次反转当前区间时，将区间内每个数都取反，时间复杂度是O(n∗k)的，这样是不够快的。需要优化一下，我们再考虑每个位置上的元素，他只会被前面K - 1个元素是否被反转所影响，所以我们只需要知道前面k - 1个元素总共反转了多少次(更进一步的说我们只关系反转次数的奇偶性)。
+
+我们使用一个队列保存i前面k - 1个位置有多少元素被反转了。
+
+如果队列长度为奇数，那么当前位置的1被变成0了需要反转，如果为偶数，说明当前位置的0还是0，需要反转。
+
+如果最后k - 1个位置还有0的话说明失败。否则将i加入队列，更新答案。
+
+时间复杂度：每个元素最多被进入队列和出队列一次，所以总的时间复杂度为O(n)
+'''
+from typing import List
+from collections import deque
+
+class Solution:
+    def minKBitFlips(self, nums: List[int], k: int) -> int:
+        n, ret = len(nums), 0
+        queue = deque([]) # 存储当前位置的 前k - 1个元素中 需要翻转的元素下标 也代表了能影响到当前位置的翻转次数
+        for i in range(n):  # 从前往后遍历每个元素
+            while queue and queue[0] + k <= i:  # 队列元素中的个数大于等于k 需要pop最早入队的 它影响不到当前i位置
+                queue.popleft()
+            
+            if nums[i] == len(queue) % 2: # 两种情况当前位置需要翻转 1.队列长度是奇数且当前值是1(奇数长度的队列会把当前值转成0) 2.队列长度是偶数且当前值是0(之后需要转成1)
+                if i + k > n:   # 最后元素不足k个了 无论如何也无法满足条件: 一次翻转必须转exact k个 无解  
+                    return -1
+                queue.append(i) # 当前下标入队
+                ret += 1        #更新所求答案
+        return ret

Tree/uber n ary tree arch view.py

@@ -0,0 +1,65 @@
+'''
+Given an N-ary tree, print the nodes seen by a person when walking from
+bottom left to bottom right in an arc via root node.
+题目描述故意给的很模糊 只能靠猜+跟对方反复确认理解.
+例子1
+         1
+       / | \
+      2  3  4
+     / \    / \
+    5   6  7   8
+输出: [5,2,1,4,8]
+
+例子2:
+         1
+       / | \
+      2  3  4
+       \    /
+        6  7  
+输出:[6,2,1,4,7]
+
+'''
+from collections import deque, defaultdict
+from typing import List
+
+class Node:
+    def __init__(self, val=0):
+        self.val = val
+        self.children = []
+
+def tree_arch_view(root: Node) -> List[int]:
+    ret = []
+    if not root:
+        return ret
+    
+    map = defaultdict(lambda: [None] * 2) # key是level, value是[0:left_most, 1:right_most] 
+    queue = deque([root])
+    level = 0
+
+    while queue:
+        size = len(queue)
+        for i in range(size):
+            node = queue.popleft()
+            if i == 0: # 当前层的第一个点 是left most node
+                map[level][0] = node.val
+            if size > 1 and i == size - 1: # 当前层的节点数>1(就一个点的话 肯定是left most) 且当前点是当前层最后一个点: right most node
+                map[level][1] = node.val
+            for child in node.children:    # 将当前点的所有子节点 从左到右入队
+                queue.append(child)
+        level += 1 # 注意bfs结束时 level比实际值多加了1
+    # print("map:", map)
+    # 从左下角开始往上遍历 所以层数倒着数
+    for i in range(level - 1, -1, -1): # bfs结束时 level比实际值多加了1 所以从level-1开始倒着遍历
+        ret.append(map[i][0])
+    # 从第二层开始沿着最右侧往下遍历 第一层的根节点 已在倒着遍历时考虑到了
+    for i in range(1, level): 
+        if map[i][1]:   # 某一层可能没有right most node  需要判断一下
+            ret.append(map[i][1])
+    return ret
+
+root = Node(1)
+root.children = [Node(2), Node(3), Node(4)]
+root.children[0].children = [Node(5), Node(6)]
+root.children[2].children = [Node(7)]
+
+print(tree_arch_view(root))