Merge remote-tracking branch 'upstream/main'

Author: mykoo

.github/workflows/integration.yaml

@@ -13,6 +13,11 @@ jobs:
   label-lang:
     runs-on: ubuntu-latest
     continue-on-error: true
+
+    permissions:
+      contents: write
+      pull-requests: write
+
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
@@ -81,5 +86,5 @@ jobs:
             }
           }
 
-          run().catch(err => console.error(err));
+          run();
           "

construct-binary-tree-from-preorder-and-inorder-traversal/HC-kang.ts

@@ -0,0 +1,53 @@
+// Definition for a binary tree node.
+class TreeNode {
+  val: number;
+  left: TreeNode | null;
+  right: TreeNode | null;
+  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+    this.val = val === undefined ? 0 : val;
+    this.left = left === undefined ? null : left;
+    this.right = right === undefined ? null : right;
+  }
+}
+
+// T.C: O(N)
+// S.C: O(N^2) - Slice makes n-1, n-2, ..., 1 for n times. So, it's O(N^2).
+function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
+  if (preorder.length === 0 || inorder.length === 0) {
+    return null;
+  }
+  const root = new TreeNode(preorder[0]);
+  const idx = inorder.indexOf(preorder[0]);
+  root.left = buildTree(preorder.slice(1, idx + 1), inorder.slice(0, idx));
+  root.right = buildTree(preorder.slice(idx + 1), inorder.slice(idx + 1));
+
+  return root;
+}
+
+// Not using slice. but I think it's not necessary... first solution is more readable. and that's not so bad.
+// T.C: O(N)
+// S.C: O(N)
+function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
+  // this tree is consist of unique values
+  const inorderMap = new Map<number, number>();
+  for (const [i, val] of inorder.entries()) {
+    inorderMap.set(val, i);
+  }
+
+  function helper(preLeft: number, preRight: number, inLeft: number, inRight: number): TreeNode | null {
+    if (preLeft > preRight) return null;
+
+    const rootValue = preorder[preLeft];
+    const root = new TreeNode(rootValue);
+    const inRootIdx = inorderMap.get(rootValue)!;
+
+    const leftSize = inRootIdx - inLeft;
+
+    root.left = helper(preLeft + 1, preLeft + leftSize, inLeft, inRootIdx - 1);
+    root.right = helper(preLeft + leftSize + 1, preRight, inRootIdx + 1, inRight);
+
+    return root;
+  }
+
+  return helper(0, preorder.length - 1, 0, inorder.length - 1);
+}

construct-binary-tree-from-preorder-and-inorder-traversal/haklee.py

@@ -0,0 +1,98 @@
+"""TC: O(n), SC: O(n)
+
+아이디어:
+- preorder 트리가 주어져 있다면 다음과 같이 분할할 수 있다.
+    - [root값, [...left], [...right]]
+    - 위의 left, right는 preorder 트리와 같은 방식으로 구성된다.
+- inorder 트리가 주어져 있다면 다음과 같이 분할할 수 있다.
+    - [[...left], root값, [...right]]
+    - 위의 left, right는 inorder 트리와 같은 방식으로 구성된다.
+    - 이때, 
+        - left의 첫 아이템이 인덱스 inorder_s에 있고,
+        - right의 마지막 아이템이 인덱스 inorder_e - 1에 있다고 하자.
+        - 즉, inorder_e를 미포함!
+- preorder 트리의 맨 앞 값을 통해 root값 val을 찾고, 이 값으로 inorder의 root값의 인덱스를 찾을 수 있다.
+    - 모든 node의 val값이 unique한 것이 조건으로 주어져 있으므로 val값의 indices를 전처리해둘 수 있다.
+    - 이때, inorder의 root값의 인덱스를 inorder_root이라고 하자.
+- inorder의 root값의 위치와 inorder 트리의 시작 위치를 알 수 있다면
+    [...left]의 길이 left_len을 알 수 있다.
+    - left_len = inorder_root - inorder_start
+- preorder 트리의 left의 루트는 [...left]의 첫 아이템, 즉, preorder_root에 1을 더한 값이다.
+- preorder 트리의 right의 루트는 [...right]의 첫 아이템, 즉, preorder_root + 1 + left_len이다.
+- root값을 구할 수 없으면 노드가 없다.
+    - inorder_s >= inorder_e와 같이 판별이 가능하다. 즉, 아이템이 하나도 없는 경우.
+
+위의 아이디어를 종합하면,
+- preorder 트리의 루트 인덱스 preorder_root가 주어진, 구간 (inorder_s, inorder_e)에서 정의된 inorder 트리는
+    - val값은 preorder[preorder_root]이 된다.
+    - left node는 아래와 같이 구해진다.
+        - preorder 트리의 루트 인덱스 preorder_root + 1,
+        - 구간 (inorder_s, inorder_root)
+        - 이때 구간이 유효하지 않으면 노드가 없다.
+    - right node는 아래와 같이 구해진다.
+        - preorder 트리의 루트 인덱스 preorder_root + 1 + left_len,
+        - 구간 (inorder_root + 1, inorder_end)
+        - 이때 구간이 유효하지 않으면 노드가 없다.
+
+
+SC:
+- 처음 inorder_indices를 계산할때 O(n).
+- 아래의 build함수 호출이 최대 트리의 깊이만큼 재귀를 돌면서 쌓일 수 있다.
+    - 트리의 깊이는 최악의 경우 O(n).
+    
+TC:
+- build함수는 O(1). 코드 참조.
+- 위의 과정을 n개의 노드에 대해 반복하므로 O(n).
+"""
+
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
+        inorder_indices = {v: i for i, v in enumerate(inorder)}
+
+        def build(inorder_s, inorder_e, preorder_root):
+            if inorder_s >= inorder_e:  # O(1)
+                return None
+            val = preorder[preorder_root]  # O(1)
+            inorder_root = inorder_indices[val]  # O(1)
+            left_len = inorder_root - inorder_s  # O(1)
+            return TreeNode(
+                val,
+                left=build(inorder_s, inorder_root, preorder_root + 1),
+                right=build(inorder_root + 1, inorder_e, preorder_root + 1 + left_len),
+            )
+
+        return build(0, len(inorder), 0)
+
+
+"""
+그런데 위의 아이디어를 다시 생각해보면, 모든 노드들을 preorder 순서로 순회한다!
+- `val = preorder[preorder_root]`와 같은 방식으로 val값을 구하지 않고, 주어진 preorder를 순서대로 가져와도 됨.
+- 즉, preorder를 iterator로 바꿔서 next를 통해 값을 하나씩 뽑아와서 건네줘도 된다.
+- 이렇게 하면 build함수에 preorder_root를 전달하지 않아도 됨.
+"""
+
+
+class Solution:
+    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
+        inorder_indices = {v: i for i, v in enumerate(inorder)}
+        preorder_iter = iter(preorder)
+
+        def build(inorder_s, inorder_e):
+            if inorder_s >= inorder_e:  # O(1)
+                return None
+            val = next(preorder_iter)  # O(1)
+            inorder_root = inorder_indices[val]  # O(1)
+            return TreeNode(
+                val,
+                left=build(inorder_s, inorder_root),
+                right=build(inorder_root + 1, inorder_e),
+            )
+
+        return build(0, len(inorder))

construct-binary-tree-from-preorder-and-inorder-traversal/whewchews.ts

@@ -0,0 +1,49 @@
+class TreeNode {
+  val: number;
+  left: TreeNode | null;
+  right: TreeNode | null;
+  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+    this.val = val === undefined ? 0 : val;
+    this.left = left === undefined ? null : left;
+    this.right = right === undefined ? null : right;
+  }
+}
+
+/**
+ * preorder: [root, left, right]
+ * inorder: [left, root, right]
+ * preorder의 첫번째 값은 root이다. (1. 현재 root 찾기)
+ * 모든 node의 val는 unique하기 때문에 이 값을 기준으로 inorder에서 root의 위치를 찾을 수 있다.
+ *
+ * inorder에서 root의 위치를 찾으면, root를 기준으로 왼쪽은 left subtree, 오른쪽은 right subtree이다. (2. left subtree, right subtree 구분)
+ * inorder: [...left, root, ...right]
+ * root값은 이미 찾았기 때문에 shift로 제거한다.
+ *
+ * 남은 preorder에서 첫번째 값은 left subtree의 root이다. (3. left subtree 구성)
+ * preorder에서 하나씩 shift하면서 왼쪽 트리를 먼저 구성한다.
+ * preorder에서 첫번째 값이 왼쪽 subtree의 root이다. (1. 현재 root 찾기)
+ *  inorder에서 root의 위치를 찾아서 왼쪽 subtree를 구성한다. (2. left subtree, right subtree 구분) (3. left subtree 구성)
+ * root 기준 왼쪽 subtree 구성이 끝나면 오른쪽 subtree를 구성한다.
+ * 위 과정을 재귀적으로 반복하면, 전체 트리를 구성할 수 있다. (1-3 과정 반복)
+ */
+function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
+  // build 함수가 각 노드마다 호출됨(N) * 각 노드마다 shift, indexOf 수행(N) = O(N^2)
+  function build(preorder, inorder) {
+    if (inorder.length) {
+      // TC: O(N)
+      const idx = inorder.indexOf(preorder.shift());
+      const root = new TreeNode(inorder[idx]);
+
+      root.left = build(preorder, inorder.slice(0, idx));
+      root.right = build(preorder, inorder.slice(idx + 1));
+
+      return root;
+    }
+    return null;
+  }
+
+  return build(preorder, inorder);
+}
+
+// TC: O(N^2)
+// SC: O(N^2)

counting-bits/HC-kang.ts

@@ -0,0 +1,26 @@
+// T.C: O(n)
+// S.C: O(n)
+function countBits(n: number): number[] {
+  // T.C: O(1)
+  // S.C: O(1)
+  function countBit(num: number): number {
+    num = num - ((num >>> 1) & 0x55555555);
+    num = (num & 0x33333333) + ((num >>> 2) & 0x33333333);
+    num = (num + (num >>> 4)) & 0x0f0f0f0f;
+    num = num + (num >>> 8);
+    num = num + (num >>> 16);
+    return num & 0x3f;
+  }
+
+  return new Array(n + 1).fill(0).map((_, i) => countBit(i));
+}
+
+// T.C: O(n)
+// S.C: O(n)
+function countBits(n: number): number[] {
+  const dp = new Array(n + 1).fill(0);
+  for (let i = 1; i <= n; i++) {
+    dp[i] = dp[i >> 1] + (i & 1);
+  }
+  return dp;
+}

counting-bits/haklee.py

@@ -0,0 +1,35 @@
+"""TC: O(n), SC: O(n)
+
+아이디어:
+- bin으로 변환한 값의 길이가 k인 모든 수들에 대한 bit_count값을 알고 있다고 하자.
+- 사실 위의 수들은 bin으로 변환했을때 맨 앞 자리가 0으로 시작하는 길이 k+1의 수라고 볼 수 있다.
+- 그렇다면 bin으로 변환했을때 맨 앞 자리가 1로 시작하는 길이 k+1인 수들의 bit_count는
+    맨 앞 자리가 0으로 시작하는 수들의 bit_count에 1을 더한 것이라고 할 수 있다.
+- 위의 아이디어를 활용하면 앞 2^k 수들의 bit_count를 알고 있으면 간단한 더하기 연산을 통해
+    이후 2^k 수들의 bit_count값도 알 수 있다.
+    e.g.)
+    - 0, 1의 bit_count가 [0, 1]이라면, 2, 3의 bit_count는 [0+1, 1+1], 즉, 0~3의 bit_count는 [0, 1, 1, 2]
+    - 0~3의 bit_count가 [0, 1, 1, 2]라면, 4~7의 bit_count는 [1, 2, 2, 3], 즉, 0~7의 bit_count는
+        [0, 1, 1, 2, 1, 2, 2, 3]
+    - ...
+- 리스트의 크기를 2배씩 늘리다가 n보다 커졌을때 앞 n개의 아이템만 취해서 리턴.
+
+
+SC:
+- 아래에서 리스트 s의 길이는 2^(k-1) < n <= 2^k를 만족하는 2^k만큼 커진다.
+- 즉, O(n).
+
+TC:
+- s 안에 들어있는 i번째 아이템을 계산할때 필요한 연산은 덧셈 1회, 즉, O(1).
+- i번째 아이템 값을 구하기 위해 그 앞의 값을 미리 계산해둔 것이라 생각할 수 있다.
+- SC 분석과 비슷하게, 2^(k-1) < n <= 2^k를 만족하는 2^k만큼 반복. 즉, O(n).
+"""
+
+
+class Solution:
+    def countBits(self, n: int) -> List[int]:
+        s = [0]
+        m = n * 2
+        while m := m >> 1:
+            s += [i + 1 for i in s]
+        return s[: n + 1]

counting-bits/jaejeong1.java

@@ -0,0 +1,26 @@
+class SolutionCountingBits {
+  public int[] countBits(int n) {
+    // 0 ~ n 까지의 수를 이진수로 변환한다음, 1의 개수를 카운트해 배열로 반환
+    // 홀수/짝수 여부를 나눠서 1의 개수를 구함
+    // 홀수: 이전 값 + 1, 짝수: i / 2의 1의 개수와 같은 값
+    // 시간복잡도: O(N), 공간복잡도: O(N)
+
+    int[] countingBits = new int[n + 1];
+    countingBits[0] = 0;
+
+    for (int i=1; i<=n; i++) {
+      if (isOddNumber(i)) {
+        countingBits[i] = countingBits[i - 1] + 1;
+      } else {
+        countingBits[i] = countingBits[i / 2];
+      }
+    }
+
+    return countingBits;
+  }
+
+  // 시간복잡도: O(1)
+  private boolean isOddNumber(int n) {
+    return n % 2 == 1;
+  }
+}

counting-bits/whewchews.ts

@@ -0,0 +1,19 @@
+function countBits(n: number): number[] {
+  // SC: O(N)
+  const ans = Array(n + 1).fill(0);
+  // TC: O(N)
+  for (let i = 1; i <= n; i++) {
+    let k = i;
+
+    // TC: O(log N)
+    while (k > 0) {
+      ans[i] += k % 2;
+      k = Math.floor(k / 2);
+    }
+  }
+
+  return ans;
+}
+
+// TC: O(N log N)
+// SC: O(N)

decode-ways/HC-kang.ts

@@ -0,0 +1,31 @@
+// T.C: O(n)
+// S.C: O(n)
+function numDecodings(s: string): number {
+  const NUM_OF_ALPHA = 26;
+  const memo = new Map<number, number>();
+
+  function dfs(idx: number): number {
+    if (idx === s.length) {
+      return 1;
+    }
+    if (s[idx] === '0') {
+      return 0;
+    }
+    if (memo.has(idx)) {
+      return memo.get(idx)!;
+    }
+
+    let count = dfs(idx + 1);
+    if (
+      idx + 2 <= s.length && // check if idx + 2 is in the range
+      parseInt(s.slice(idx, idx + 2), 10) <= NUM_OF_ALPHA
+    ) {
+      count += dfs(idx + 2);
+    }
+
+    memo.set(idx, count);
+    return count;
+  }
+
+  return dfs(0);
+}

decode-ways/haklee.py

@@ -0,0 +1,32 @@
+"""TC: O(n), SC: O(1)
+
+아이디어: 
+뒷 k개의 글자를 디코딩 하는 경우의 수를 f(k)라고 하자.
+f(k)는 다음의 두 경우의 수를 더한 값이다.
+  - 뒷 k개의 글자 중 첫 글자가 디코딩 가능한 경우, 뒷 k-1글자를 디코딩하는 경우의 수
+  - 뒷 k개의 글자 중 앞 두 글자가 디코딩 가능한 경우, 뒷 k-2글자를 디코딩하는 경우의 수
+즉, f(k) = (앞 두 글자 판별)*f(k-2) + (앞 한 글자 판별)*f(k-1)
+
+
+SC:
+- tabulation 과정에서 값 2개만 계속 유지한다.
+- 즉, O(1).
+
+TC:
+- f(k) 구하는 식: O(1)
+    - 두 글자가 디코딩 가능한지 판별: O(1)
+    - 첫 글자가 디코딩 가능한지 판별: O(1)
+- 위의 f(k)를 구하는 것을 s의 길이에서 2를 뺀 수만큼 루프, 즉, O(n)
+- 종합하면 O(n).
+"""
+
+
+class Solution:
+    def numDecodings(self, s: str) -> int:
+        # init
+        x, y = 1, int(int(s[-1]) != 0)  # f(0), f(1)
+        # tabulation
+        for i in range(len(s) - 2, -1, -1):  # 뒷 k개 글자의 시작 글자가 s[i]
+            # f(k-2), f(k-1)을 f(k-1), f(k)로
+            x, y = y, (x * (10 <= int(s[i : i + 2]) <= 26)) + (y * (int(s[i]) != 0))
+        return y