Merge branch 'DaleStudy:main' into main

Author: gitsunmin

.github/workflows/automation.yaml

@@ -24,3 +24,28 @@ jobs:
       - uses: actions/labeler@v5
         with:
           repo-token: ${{ github.token }}
+
+  assign-reviewer:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get previous PR author and assign as reviewer
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        run: |
+          current_repo=${{ github.repository }}
+          current_pr_num=${{ github.event.number }}
+
+          # 이전 PR 중에서 현재 PR 작성자와 다른 작성자 찾기
+          previous_pr_author=$(gh pr list --repo $current_repo \
+            --state all \
+            --search "created:<${{ github.event.pull_request.created_at }} sort:created-desc -author:${{ github.actor }}" \
+            --limit 3 \
+            --json number,author \
+            --jq "map(select(.number < $current_pr_num))[0].author.login")
+          
+          if [ -n "$previous_pr_author" ]; then
+            gh pr edit $current_pr_num --repo $current_repo --add-reviewer $previous_pr_author
+          else
+            echo "❌ No previous PR author found to assign as reviewer"
+            exit 1
+          fi

find-median-from-data-stream/flynn.go

@@ -0,0 +1,67 @@
+/*
+풀이
+- 이진탐색을 이용합니다
+Big O
+- N: 현재 MedianFinder.nums의 크기
+- AddNum
+  - Time complexity: O(N)
+    - bisect -> O(logN)
+	- slices.Insert -> O(N)
+  - Space complexity: O(1)
+- FindMedian
+  - Time complexity: O(1)
+  - Space complexity: O(1)
+*/
+
+import "slices"
+
+type MedianFinder struct {
+	nums []int
+}
+
+func Constructor() MedianFinder {
+	mf := MedianFinder{}
+	mf.nums = make([]int, 0)
+	return mf
+}
+
+func (this *MedianFinder) AddNum(num int) {
+	n := len(this.nums)
+	if n == 0 {
+		this.nums = append(this.nums, num)
+	} else {
+		idx := bisectLeft(this.nums, num)
+		this.nums = slices.Insert(this.nums, idx, num)
+	}
+}
+
+func (this *MedianFinder) FindMedian() float64 {
+	n := len(this.nums)
+	if n%2 == 0 {
+		return (float64(this.nums[n/2-1]) + float64(this.nums[n/2])) / 2
+	} else {
+		return float64(this.nums[n/2])
+	}
+}
+
+// ----- Helper -----
+func bisectLeft(arr []int, x int) int {
+	lo := 0
+	hi := len(arr)
+	for lo < hi {
+		mid := lo + (hi-lo)/2
+		if arr[mid] < x {
+			lo = mid + 1
+		} else {
+			hi = mid
+		}
+	}
+	return lo
+}
+
+/**
+ * Your MedianFinder object will be instantiated and called as such:
+ * obj := Constructor();
+ * obj.AddNum(num);
+ * param_2 := obj.FindMedian();
+ */

house-robber/flynn.go

@@ -0,0 +1,72 @@
+/*
+풀이 1
+- DP를 이용하여 풀이합니다
+  아래 배열 두 개를 이용합니다
+  robbed[i]: i번째 집을 털면서 구한 rob(nums[:i+1])의 최대값
+  unrobbed[i]: i번째 집을 안 털면서 구한 rob(nums[:i+1])의 최대값
+  두 배열을 이용하여 아래와 같은 점화식을 세울 수 있습니다
+  robbed[i] = nums[i] + max(robbed[i-2], unrobbed[i-1])
+  unrobbed[i] = max(robbed[i-1], unrobbed[i-1])
+Big O
+- N: nums의 길이
+- Time complexity: O(N)
+- Space complexity: O(N)
+*/
+
+func rob(nums []int) int {
+	n := len(nums)
+
+	if n == 1 {
+		return nums[0]
+	}
+
+	robbed := make([]int, n)
+	robbed[0] = nums[0]
+	robbed[1] = nums[1]
+
+	unrobbed := make([]int, n)
+	unrobbed[1] = nums[0]
+
+	for i := 2; i < n; i++ {
+		robbed[i] = nums[i] + max(robbed[i-2], unrobbed[i-1])
+		unrobbed[i] = max(robbed[i-1], unrobbed[i-1])
+	}
+
+	return max(robbed[n-1], unrobbed[n-1])
+}
+
+/*
+풀이 2
+- 풀이 1과 동일한데, memoization을 위해 배열을 사용하지 않습니다
+  robbed[i], unrobbed[i] 계산에는 robbed[i-2], robbed[i-1], unrobbed[i-1]만 있어도 충분하기 때문입니다
+Big O
+- N: nums의 길이
+- Time complexity: O(N)
+- Space complexity: O(1)
+*/
+
+func rob(nums []int) int {
+	n := len(nums)
+
+	if n == 1 {
+		return nums[0]
+	}
+
+	ppRobbed := nums[0]  // robbed[i-2]에 해당
+	pRobbed := nums[1]   // robbed[i-1]에 해당
+	pUnrobbed := nums[0] // unrobbed[i-1]에 해당
+
+	for i := 2; i < n; i++ {
+		ppRobbed, pRobbed, pUnrobbed = pRobbed, nums[i]+max(ppRobbed, pUnrobbed), max(pRobbed, pUnrobbed)
+	}
+
+	return max(pRobbed, pUnrobbed)
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	} else {
+		return b
+	}
+}

house-robber/jaejeong1.java

@@ -0,0 +1,20 @@
+class Solution {
+  public int rob(int[] nums) {
+    // 인접한 경우는 제외한 최대 합
+    // 풀이: dp로 풀이한다. dp[i] = max(dp[i-1], dp[i-2] + nums[i])
+    // TC: O(N), SC: O(N)
+    if (nums.length == 1) {
+      return nums[0];
+    }
+
+    var dp = new int[nums.length];
+    dp[0] = nums[0];
+    dp[1] = Math.max(nums[0], nums[1]);
+
+    for (int i=2; i<nums.length; i++) {
+      dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i]);
+    }
+
+    return dp[nums.length-1];
+  }
+}

house-robber/jdalma.kt

@@ -0,0 +1,65 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+import kotlin.math.max
+
+class `house-robber` {
+
+    fun rob(nums: IntArray): Int {
+        return usingDP(nums)
+    }
+
+    /**
+     * TC: O(n), SC: O(n)
+     */
+    private fun usingDP(nums: IntArray): Int {
+        val dp = IntArray(nums.size + 1).apply {
+            this[0] = 0
+            this[1] = nums[0]
+        }
+        for (index in 1 until nums.size) {
+            dp[index + 1] = max(nums[index] + dp[index - 1], dp[index])
+        }
+
+        return dp[nums.size]
+    }
+
+    /**
+     * TC: O(n), SC: O(n)
+     */
+    private fun usingMemoization(nums: IntArray): Int {
+        val memo = IntArray(nums.size) { -1 }
+        fun recursive(index: Int): Int {
+            return if (index > nums.size - 1) 0
+            else if (memo[index] != -1) memo[index]
+            else {
+                memo[index] = max(nums[index] + recursive(index + 2), recursive(index + 1))
+                memo[index]
+            }
+        }
+
+        return recursive(0)
+    }
+
+    /**
+     * 시간초과
+     * TC: O(2^n), SC: O(n)
+     */
+    private fun usingRecursive(nums:IntArray): Int {
+        fun recursive(index: Int, depth: Int): Int {
+            if (index > nums.size - 1) return 0
+            println("${"-".repeat(depth)} : max($index + ${index + 2}, ${index + 1})")
+            return max(nums[index] + recursive(index + 2, depth + 1), recursive(index + 1, depth + 1))
+        }
+
+        return recursive(0, 0)
+    }
+
+    @Test
+    fun `인접하지 않은 원소를 선택하여 최대의 합을 반환한다`() {
+        rob(intArrayOf(1,2,3,1)) shouldBe 4
+        rob(intArrayOf(2,7,9,3,1)) shouldBe 12
+        rob(intArrayOf(8,7,9,11,1)) shouldBe 19
+    }
+}

house-robber/kayden.py

@@ -0,0 +1,11 @@
+class Solution:
+    # 시간복잡도: O(N)
+    # 공간복잡도: O(1)
+    def rob(self, nums: List[int]) -> int:
+        one, two = 0, 0
+
+        for num in nums:
+            temp = max(two+num, one)
+            two, one = one, temp
+
+        return one

house-robber/mangodm-web.py

@@ -0,0 +1,27 @@
+from typing import List
+
+
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        """
+        - Idea: i번째 집까지의 최대 금액은 두 가지 중 더 큰 값으로 결정된다.
+            1. (i-2번째 집까지의 최대 금액) + i번째 집의 금액
+            2. (i-1번째 집까지의 최대 금액)
+            이를 이용해 동적 프로그래밍으로 각 집까지의 최대 금액을 계산한다.
+            중간 결과를 저장할 배열을 만들고 순차적으로 값을 채우면, 맨 마지막 값이 전체 최대 금액이 된다.
+        - Time Complexity: O(n). n은 집의 개수.
+            모든 집을 한번씩 순회해야 하므로 O(n) 시간이 걸린다.
+        - Space Complexity: O(n). n은 집의 개수.
+            각 집까지의 최대 금액을 저장하기 위해 배열을 사용하므로 O(n) 만큼의 메모리가 필요하다.
+        """
+        if len(nums) == 1:
+            return nums[0]
+
+        dp = [0] * len(nums)
+        dp[0] = nums[0]
+        dp[1] = max(nums[0], nums[1])
+
+        for i in range(2, len(nums)):
+            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])
+
+        return dp[-1]

lowest-common-ancestor-of-a-binary-search-tree/flynn.go

@@ -0,0 +1,35 @@
+/*
+풀이
+- common ancestor라는 조건에 맞는 node를 찾아냅니다
+  for common ancestor C, left subtree of C includes p (p.Val <= C.Val)
+                     and right subtree of C includes q (C.Val <= q.Val)
+  이러한 조건을 만족하는 common ancestor는 BST에 하나만 존재합니다
+  따라서 common ancestor를 찾으면 그게 곧 lowest common ancestor입니다
+Big O
+- N: 노드의 개수
+- H: 트리의 높이 (avg: logN, worst: N)
+- Time complexity: O(H)
+- Space complexity: O(H)
+*/
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val   int
+ *     Left  *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+
+ func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
+	if p.Val > q.Val { // p < q가 되도록 함
+		return lowestCommonAncestor(root, q, p)
+	}
+	if p.Val <= root.Val && root.Val <= q.Val { // common ancestor를 찾음
+		return root
+	} else if q.Val < root.Val { // left subtree 탐색
+		return lowestCommonAncestor(root.Left, p, q)
+	} else { // right subtree 탐색
+		return lowestCommonAncestor(root.Right, p, q)
+	}
+}

lowest-common-ancestor-of-a-binary-search-tree/jaejeong1.java

@@ -0,0 +1,33 @@
+
+//  Definition for a binary tree node.
+class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+
+    TreeNode(int x) {
+        val = x;
+    }
+}
+
+
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        // 플이: p,q 둘다 root 보다 값이 적으면 왼쪽 서브트리를, 둘다 크면 오른쪽 서브트리를 탐색해야한다.
+        // 그렇지 않으면 해당 root가 최저 공통 조상이 된다.
+        // TC: O(H), H: 트리의 높이
+        // SC: O(1)
+        var node = root;
+        while (node != null) {
+            if (p.val < node.val && q.val < node.val) {
+                node = node.left;
+            } else if (p.val > node.val && q.val > node.val) {
+                node = node.right;
+            } else {
+                break;
+            }
+        }
+
+        return node;
+    }
+}