update

Author: CSStudySession

BinarySearch/LC528 Random Pick with Weight.py

@@ -20,7 +20,9 @@
 
 问题转化为: 随机出一个[1,max_prefix_sum]之间的整数target 然后二分前缀和数组 
 找到第一个大于等于target的值 等价于找到了这个随机数落在了哪个长度的区间内
-二分找到的值 代表了所在区间长度的右端点 它的下标 也就是w原数组的下标  
+二分找到的值 代表了所在区间长度的右端点 它的下标 也就是w原数组的下标 
+
+测试方法: 1) fix target 比较output 2)call this multiple times
 '''
 
 import random

Meta/LC1650 Lowest Common Ancestor of a Binary Tree III.py

@@ -0,0 +1,52 @@
+'''
+Given two nodes of a binary tree p and q, return their lowest common ancestor (LCA).
+Each node will have a reference to its parent node. The definition for Node is below:
+'''
+
+class Node:
+    def __init__(self, val):
+        self.val = val
+        self.left = None
+        self.right = None
+        self.parent = None
+
+# method 1. 计算两个节点的深度. 深的节点往上跳 直到两个节点深度一致. 然后两个节点同时往上跳 汇合时即为LCA
+# T: O(n)  S: O(1)
+def lowestCommonAncestor(self, p: 'Node', q: 'Node') -> 'Node':
+    p_depth = self.getDepth(p)
+    q_depth = self.getDepth(q)
+
+    # 更深的节点向上移动 直到same level
+    for _ in range(p_depth - q_depth):
+        p = p.parent
+    for _ in range(q_depth - p_depth):
+        q = q.parent
+    
+    # at the same level, return until they meet. 
+    while p != q:
+        p = p.parent
+        q = q.parent
+    return p
+
+def getDepth(self, node):
+    dep = 0
+    while node:
+        dep += 1
+        node = node.parent
+    return dep
+
+# method 2: 用set存储p的所有parents. q向上找, 如果parent in set, 则是LCA
+# T: O(n)  S: O(n)
+def lowestCommonAncestor(self, p: 'Node', q: 'Node') -> 'Node':
+    if not p or not q: return None
+    parentSet = set()
+    while p:
+        parentSet.add(p)
+        p = p.parent
+
+    while q:
+        if q in parentSet:
+            return q
+        else:
+            q = q.parent
+    return None

Meta/LC1762 Buildings With an Ocean View.py

@@ -0,0 +1,17 @@
+'''
+ocean在右边.要求返回有o view元素的下标 下标从小到大返回.
+'''
+
+'''
+solution: monotolic stack. stack存下标 下标对应元素的高度单调增 stack top的高度最小
+T: O(n)  S: O(n)
+'''
+def findBuildings(heights: List[int]) -> List[int]:
+    if not heights:
+        return []
+    stack = []
+    for i in range(len(heights)):
+        while stack and heights[stack[-1]] <= heights[i]:
+            stack.pop() # 栈顶对应的高度<=当前高度 则栈顶一定没有o view
+        stack.append(i)
+    return stack

Meta/LC227 Basic Calculator II.py

@@ -0,0 +1,64 @@
+# 包括加减乘除 没有括号
+
+'''
+    linear scan: time O(n) space O(1)
+    let ch be current char in s
+    1. 如果ch.isdigit() 记录number
+    2. 如果当前ch in "+-/*", 看previous sign(op): cur此时累进计算前面的+-*/
+        2.1 如果当前ch in "+-", 把cur累加到ret, cur归零
+        2.2 pre_op = ch(把当前ch给pre_op, 用pre_op记录previous operator), num归零
+'''
+def calculate0(s) -> int:
+    if not s:
+        return 0
+    
+    ret, cur = 0, 0
+    pre_op = '+'
+
+    s += '+' # 最后一个数可能会被漏掉 在s后面append一个'+' 方便计算
+    num = 0 # 截取s中的数字 可能有多位数
+    
+    for ch in s:
+        if ch.isdigit():
+            num = num * 10 + int(ch) # 注意这里是= 不是+=
+        
+        if ch in ('+', '-', '*', '/'):
+            if pre_op == '+':
+                cur += num
+            elif pre_op == '-':
+                cur -= num
+            elif pre_op == '*':
+                cur *= num
+            else: # pre_op is '/'
+                cur = int(cur / num) # 有可能有负数除法 要用int() 不能用//
+            # 这里的if 和下面堆pre_op/num赋值 都在ch是运算符的if条件下
+            if ch in ('+', '-'):
+                ret += cur
+                cur = 0
+            
+            pre_op = ch
+            num = 0
+
+    return ret
+
+# method 2: stack T O(n) S O(n)
+def calculate1(self, s: str) -> int:
+    stack = []
+    num = 0
+    sign = "+"
+    for i, c in enumerate(s):
+        if c.isdigit():
+            num = num * 10 + int(c)
+        if c in "+-*/" or i == len(s) - 1: #最后一个数 既要参与上面if计算 也要在这里计算. 所以不能用elif
+            if sign == "+":
+                stack.append(num)
+            if sign == "-":
+                stack.append(-num)
+            if sign == "*":
+                stack.append(stack.pop() * num)
+            if sign == "/":
+                stack.append(int(stack.pop() / num)) # "//"不能做负数运算 需要用int(a/b)
+            
+            sign = c
+            num = 0
+    return sum(stack)

Meta/LC339 Nested List Weight Sum.py

@@ -0,0 +1,48 @@
+'''
+given a nested list of integers nestedList. Each element is either an integer or a list whose elements may also be integers or other lists.
+The depth of an integer is the number of lists that it is inside of. For example, the nested list [1,[2,2],[[3],2],1] has each integer's value set to its depth.
+Return the sum of each integer in nestedList multiplied by its depth.
+Example 1:
+Input: nestedList = [[1,1],2,[1,1]]
+Output: 10
+Explanation: Four 1's at depth 2, one 2 at depth 1. 1*2 + 1*2 + 2*1 + 1*2 + 1*2 = 10.
+'''
+
+'''
+解法1:bfs. say N is the total number of nested elements in input: nested list + integers.
+T: O(N)  S: O(N)
+'''
+
+def depthSum0(nestedList: List[NestedInteger]) -> int:
+    if not nestedList:
+        return 0
+    level = 1
+    queue = collections.deque(nestedList) #这里不要加"[]":把nestedList对象入队,不能变成list结构!
+    ret = 0
+    while queue:
+        for _ in range(len(queue)): # 遍历当前层
+            cur = queue.popleft()
+            if cur.isInteger():
+                ret += cur.getInteger() * level
+            else:
+                queue.extend(cur.getList()) # 取出当前item的内置items入队
+        level += 1 # 当前层遍历完
+    return ret
+
+'''
+解法1:dfs. say N is the total number of nested elements in input: nested list + integers.
+T: O(N)  S: O(N) for recursive call stack. e,g, [[[[1]]]]
+'''
+def depthSum1(nestedList: List[NestedInteger]) -> int:
+    if not nestedList:
+        return 0
+    return self.dfs(nestedList, 1)
+
+def dfs(nestedList: List[NestedInteger], level: int) -> int:
+    ret = 0
+    for item in nestedList: # 遍历的是List of NestedInteger
+        if item.isInteger():
+            ret += item.getInteger() * level
+        else: # 不可以直接算的 用getList()取出来 递归往下传 level+1
+            ret += self.dfs(item.getList(), level + 1)
+    return ret

Meta/LC50 Pow(x, n).py

@@ -0,0 +1,33 @@
+# method 1: iterative. time o(logn) space o(1)
+def myPow(self, x: float, n: int) -> float:
+    if n == 0:
+        return 1
+
+    # Handle case where, n < 0.
+    if n < 0:
+        n = -1 * n
+        x = 1.0 / x
+
+    # Perform Binary Exponentiation.
+    result = 1
+    while n != 0:
+        # If 'n' is odd 
+        if n % 2 == 1:
+            result *= x
+            n -= 1
+        # We square 'x' and reduce 'n' by half, x^n => (x^2)^(n/2).
+        x *= x
+        n //= 2
+    return result
+
+# method2: recursive time O(logn) space O(h) at most o(logn)
+def myPow(self, x: float, n: int) -> float:
+    if x == 0: return 0
+    if x == 1: return 1
+    if n == 0: return 1
+    if n < 0: 
+        return 1/self.myPow(x, -n)
+    if n % 2 == 0:
+        return self.myPow(x*x, n // 2)
+    else: # n%2==1
+        return x * self.myPow(x, n - 1) # x在外面乘

Meta/LC71 Simplify Path.py

@@ -0,0 +1,59 @@
+'''
+Meta version
+Given current directory and change directory path, return final path.
+
+For Example:
+Curent                 Change            Output
+
+/                    /facebook           /facebook
+/facebook/anin       ../abc/def          /facebook/abc/def
+/facebook/instagram   ../../../../.      /
+'''
+
+def change_path(cwd: str, cd: str) -> str:
+    path = cwd + "/" + cd  # 先把两个path用'/'连起来
+    stack = []
+    for dir in path.split('/'):
+        if dir == ".":
+            continue
+        elif dir == "..":
+            if stack: 
+                stack.pop()
+        elif not dir:  # 注意 如果当前dir为空 题意需要回到根目录 
+            stack.clear()
+        else:
+            stack.append(dir)
+
+    return "/" + "/".join(stack)
+
+# unit test
+cwd1 = '/facebook/anin'
+cd1 = '../abc/def'
+print(change_path(cwd1, cd1))
+cwd2 = '/'
+cd2 = '/facebook'
+print(change_path(cwd2, cd2))
+cwd3 = '/facebook/anin'
+cd3 = '..//def'
+print(change_path(cwd3, cd3))
+
+'''
+用stack存最终返回path里面的子path
+用'/'把input split成list
+如果遇到“..”: 
+如果有stack就pop. 如果“.” or "", continue. else stack.append
+'''
+def simplifyPath(self, path: str) -> str:
+    if not path:
+        return ""
+    stack = []
+    path_list = path.split("/")
+    for item in path_list:
+        if item == "." or item == "":
+            continue
+        elif item == "..": # 退到上一层
+            if stack:
+                stack.pop()
+        else:
+            stack.append(item)
+    return "/" + "/".join(stack) # 前面加一个'/'

Meta/LC88 Merge Sorted Array.py

@@ -0,0 +1,54 @@
+from typing import List
+# meta version: output no duplicates
+def merge_no_duplicates(nums1: List[int], nums2: List[int]) -> None:
+    res = []
+    i, j = 0, 0
+    while i < len(nums1) and j < len(nums2):
+        if nums1[i] <= nums2[j]:
+            if not res or res[-1] != nums1[i]:
+                res.append(nums1[i])
+            i += 1
+        else:
+            if not res or res[-1] != nums2[j]:
+                res.append(nums2[j])
+            j += 1
+    
+    while i < len(nums1):
+        if not res or res[-1] != nums1[i]:
+            res.append(nums1[i])
+        i += 1
+    while j < len(nums2):
+        if not res or res[-1]!= nums2[j]:
+            res.append(nums2[j])
+        j += 1
+    return res
+
+nums1 = [1,1,2,2,5,5]
+nums2 = [3,3,4,4]
+nums3 = []
+print(merge_no_duplicates(nums3, nums3))
+
+# in-place modify. need to go backward.
+def merge(nums1: List[int], m: int, nums2: List[int], n: int) -> None:
+    """
+    Do not return anything, modify nums1 in-place instead.
+    """
+    i, j, k = m - 1, n - 1, m + n - 1
+    while i >= 0 and j >= 0:
+        if nums1[i] >= nums2[j]:
+            nums1[k] = nums1[i]
+            i -= 1
+            k -= 1
+        else:
+            nums1[k] = nums2[j]
+            j -= 1
+            k -= 1
+
+    while i >= 0:
+        nums1[k] = nums1[i]
+        i -= 1
+        k -= 1
+    while j >=0:
+        nums1[k] = nums2[j]
+        j -= 1
+        k -= 1

Meta/Meta Generate random max index.py

@@ -0,0 +1,30 @@
+'''
+Given an array of integers arr, randomly return an index of the maximum value seen by far.
+Example:
+Input: [11, 30, 2, 30, 30, 30, 6, 2, 62, 62]
+Having iterated up to the at element index 5 (where the last 30 is), randomly give an index among [1, 3, 4, 5] which are indices of 30 - the max value by far. Each index should have a ¼ chance to get picked.
+Having iterated through the entire array, randomly give an index between 8 and 9 which are indices of the max value 62.
+'''
+import random
+
+# 思路: reservoir sampling T(n) S(1)
+def max_random_index(nums):
+    max_val = float('-inf')
+    idx_max = -1
+    count = 0
+
+    for i, n in enumerate(nums):
+        if n > max_val:
+            max_val = n
+            count = 1
+            idx_max = i
+        elif n == max_val:
+            count += 1
+            r = random.randint(1, count)
+            if r == 1:
+                idx_max = i
+  
+        print(i, idx_max)
+
+nums = [11, 30, 2, 30, 30, 30, 6, 2, 62, 62]
+print(max_random_index(nums))