Merge branch 'DaleStudy:main' into main

Author: Yjason-K

clone-graph/forest000014.java

@@ -70,7 +70,7 @@ public void dfs(Node oldNode) {
                 Node newNeighbor = createNode(oldNeighbor.val);
                 newNode.neighbors.add(newNeighbor);
                 newNeighbor.neighbors.add(newNode);
-                dfs(oldNeighbor, newNeighbor);
+                dfs(oldNeighbor);
             }
         }
     }

find-minimum-in-rotated-sorted-array/Chaedie.py

@@ -0,0 +1,40 @@
+"""
+Solution: 
+    1) 순회하며 이전 값이 현재 값보다 크거나 같다면 현재 값이 최소값이다.
+    2) 끝까지 돌아도 최소값이 없을 경우 첫번쨰 값이 최소값이다.
+Time: O(n)
+Space: O(1)
+"""
+
+
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        for i in range(1, len(nums)):
+            if nums[i - 1] >= nums[i]:
+                return nums[i]
+
+        return nums[0]
+
+    """
+    Solution: 
+        시간 복잡도 O(log n)으로 풀기 위해 binary search 사용
+    Time: O(log n)
+    Space: O(1)
+    """
+
+    def findMin(self, nums: List[int]) -> int:
+        l, r = 1, len(nums) - 1
+
+        while l <= r:
+            mid = (l + r) // 2
+            # prev 값보다 mid 가 작으면 찾던 값
+            if nums[mid - 1] > nums[mid]:
+                return nums[mid]
+            # mid 까지 정상 순서면 우측 탐색
+            if nums[0] < nums[mid]:
+                l = mid + 1
+            # mid 까지 비 정상 순서면 좌측 탐색
+            else:
+                r = mid - 1
+        # 못찾을 경우 전체 정상 순서 케이스
+        return nums[0]

find-minimum-in-rotated-sorted-array/Jeehay28.js

@@ -0,0 +1,49 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+
+// Binary Search
+// Time Complexity: O(log n) (Binary search halving the search space each step)
+// Space Complexity: O(1) (No extra space except for a few variables)
+var findMin = function (nums) {
+  // Example Rotations:
+  // nums = [0,1,2,4,5,6,7]
+  // [4,5,6,7,0,1,2] -> Rotated 4 times
+  // [0,1,2,4,5,6,7] -> 7 times rotated
+
+  // Initial State:
+  // [4, 5, 6, 7, 0, 1, 2]
+  //  ↑                 ↑
+  // (left)           (right)
+  //
+  // Find mid:
+  // [4, 5, 6, 7, 0, 1, 2]
+  //  ↑       🎯        ↑
+  // (left)   (mid)   (right)
+  //
+  // If nums[mid] > nums[right], move left to search in the right half:
+  // [4, 5, 6, 7, 0, 1, 2]
+  //              ↑     ↑
+  //          (left)   (right)
+
+  let left = 0;
+  let right = nums.length - 1;
+
+  while (left < right) {
+    let mid = Math.floor((left + right) / 2);
+
+    if (nums[mid] > nums[right]) {
+      // Minimum must be in the right half
+      // Need to update left to search in the right half
+      left = mid + 1;
+    } else {
+      // Minimum is in the left half (including mid)
+      // Need to update right to search in the left half
+      right = mid;
+    }
+  }
+
+  return nums[left];
+};
+

find-minimum-in-rotated-sorted-array/YeomChaeeun.ts

@@ -0,0 +1,37 @@
+/**
+ * 정렬된 배열에서 최소값 찾기
+ * 알고리즘 복잡도
+ * - 시간 복잡도: O(logn)
+ * - 공간 복잡도: O(1)
+ * @param nums
+ */
+function findMin(nums: number[]): number {
+    // 풀이 1 - sort() 사용
+    // 시간 복잡도: O(nlogn) / 공간 복잡도: O(1)
+    // nums.sort((a, b) => a - b)
+    // return nums[0]
+
+    // 풀이 2 - 배열이 정렬되어 있음을 활용한 풀이
+    // 시간 복잡도: O(n) / 공간 복잡도: O(1)
+    // let min = nums[0];
+    // for(let i = 1; i < nums.length; i++) {
+    //     console.log(nums[i])
+    //     min = Math.min(nums[i], min)
+    // }
+    // return min
+
+    // 이분 탐색법 활용
+    // 절반씩 잘라서 nums[n-1] > nums[n] 의 지점을 찾는다
+    let low = 0;
+    let high = nums.length - 1;
+    while(low < high) {
+        let mid = low + Math.floor((high - low) / 2);
+
+        if(nums[mid] > nums[high]) {
+            low = mid + 1;
+        } else {
+            high = mid;
+        }
+    }
+    return nums[low]
+}

find-minimum-in-rotated-sorted-array/dusunax.py

@@ -0,0 +1,41 @@
+'''
+# 153. Find Minimum in Rotated Sorted Array
+
+> **why binary search works in a "rotated" sorted array?**  
+> rotated sorted array consists of **two sorted subarrays**, and the minimum value is the second sorted subarray's first element.  
+> so 👉 find the point that second sorted subarray starts.   
+>
+> - if nums[mid] > nums[right]? => the pivot point is in the right half.  
+> - if nums[mid] <= nums[right]? => the pivot point is in the left half.  
+> - loop until left and right are the same.
+'''
+class Solution:
+    '''
+    ## A. brute force(not a solution)
+    - TC: O(n)
+    - SC: O(1)
+    '''
+    def findMinBF(self, nums: List[int]) -> int:
+        if len(nums) == 1:
+            return nums[0]
+
+        return min(nums) # check all elements
+
+    '''
+    ## B. binary search
+    - TC: O(log n)
+    - SC: O(1)
+    '''
+    def findMinBS(self, nums: List[int]) -> int:
+        left = 0
+        right = len(nums) - 1
+
+        while left < right:
+            mid = (left + right) // 2
+            
+            if nums[mid] > nums[right]:
+                left = mid + 1
+            else:
+                right = mid
+
+        return nums[left]

find-minimum-in-rotated-sorted-array/ekgns33.java

@@ -0,0 +1,56 @@
+/**
+ input : array of integers
+ output : minimum element's value
+
+ 3 4 5 1 2
+ draw graph
+
+ 5
+ 4
+ 3
+ 2
+ 1
+ l    r
+ l    r
+ l            r
+ --------------
+ 5
+ 4
+ 3
+ 2
+ 1
+ mid  right
+ --------------
+ left < right ->> sorted.
+ left < mid ->>  don't have to search range [left, mid]
+ mid > right ->> rotation point is between [mid, right];
+
+ solution 1) brute force
+ read the array
+
+ tc : O(n)
+ sc : O(1);
+
+ solution 2) binary search
+ do binary search, move pointers with descripted conditions
+ after binary search loop ends, the left pointer is the minimum element
+
+ tc : O(logn)
+ sc : O(1)
+ */
+
+class Solution {
+  public int findMin(int[] nums) {
+    int l = 0;
+    int r = nums.length - 1;
+    while(l < r) {
+      int mid = (r - l) / 2 + l;
+      if(nums[mid] < nums[r]) {
+        r = mid;
+      } else {
+        l = mid + 1;
+      }
+    }
+    return nums[l];
+  }
+}

find-minimum-in-rotated-sorted-array/eunhwa99.java

@@ -0,0 +1,17 @@
+class Solution {
+  // TC: O(log N)
+  // SC: O(1)
+  public int findMin(int[] nums) {
+    int left = 0;
+    int right = nums.length - 1;
+    while (left < right) {
+      int mid = left + (right - left) / 2;
+      if (nums[mid] < nums[right]) {
+        right = mid;
+      } else {
+        left = mid + 1;
+      }
+    }
+    return nums[left];
+  }
+}

find-minimum-in-rotated-sorted-array/forest000014.java

@@ -0,0 +1,38 @@
+/*
+# Time Complexity: O(logn)
+# Space Complexity: O(1)
+
+binary search를 사용해 접근했습니다.
+sorted array인 경우는 while문 시작 전, 예외 체크를 했습니다.
+binary search를 진행하면, 각각의 loop의 mid 원소는 아래 4가지 경우 중 하나입니다.
+maximum / minimum / 앞쪽 수열의 원소 중 하나 / 뒤쪽 수열의 원소 중 하나
+maximum이거나 minimum인 경우는 더 이상 탐색할 필요 없이 종료합니다.
+앞쪽 수열인 경우, 우리가 원하는 minimum은 왼쪽에는 없으므로, left 포인터를 mid의 오른쪽으로 옮기고 다음 loop를 진행하고,
+뒤쪽 수열인 경우, 우리가 원하는 minimum은 오른쪽에는 없으므로, rigth 포인터를 mid의 왼쪽으로 옮기고 다음 loop를 진행합니다.
+
+ */
+class Solution {
+    public int findMin(int[] nums) {
+        int l = 0;
+        int r = nums.length - 1;
+
+        if (nums[l] <= nums[r]) { // sorted array인 경우 (size가 1인 경우도 포함)
+            return nums[l];
+        }
+
+        while (l <= r) {
+            int m = (r - l) / 2 + l; // 만약 문제 조건상 l, r의 합이 int 범위를 넘어가서 overflow가 생길 수 있는 경우에, 이런 식으로 overflow를 방지할 수 있다고 알고 있습니다. 이 문제는 overflow 걱정은 없지만, 나중에 실전에서 나오면 잊지 않으려고 이렇게 구현해보았습니다.
+            if (m > 0 && nums[m - 1] > nums[m]) {
+                return nums[m];
+            } else if (m < nums.length - 1 && nums[m] > nums[m + 1]) {
+                return nums[m + 1];
+            } else if (nums[m] > nums[l]) {
+                l = m + 1;
+            } else {
+                r = m - 1;
+            }
+        }
+
+        return -1;
+    }
+}

find-minimum-in-rotated-sorted-array/gmlwls96.kt

@@ -0,0 +1,24 @@
+class Solution {
+    // 시간 : O(logN) 공간 : O(1)
+    // 이분탐색.
+    fun findMin(nums: IntArray): Int {
+        var left = 0
+        var right = nums.lastIndex
+
+        while (left <= right){
+            val mid = (left + right)/2
+            when{
+                nums[mid-1] > nums[mid] -> {
+                    return nums[mid]
+                }
+                nums[0] < nums[mid] -> {
+                    left = mid + 1
+                }
+                else -> {
+                    right = mid -1
+                }
+            }
+        }
+        return nums[0]
+    }
+}

find-minimum-in-rotated-sorted-array/mike2ox.ts

@@ -0,0 +1,44 @@
+/**
+ * Source: https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/
+ * 풀이방법: 이진 탐색을 이용하여 최솟값을 찾음
+ *
+ * 시간복잡도: O(log n)
+ * 공간복잡도: O(1)
+ */
+
+function findMin(nums: number[]): number {
+  // 배열의 길이가 1인 경우
+  if (nums.length === 1) return nums[0];
+
+  let left: number = 0;
+  let right: number = nums.length - 1;
+
+  // 이미 정렬된 경우
+  if (nums[right] > nums[0]) {
+    return nums[0];
+  }
+
+  // 이진 탐색
+  while (left <= right) {
+    const mid: number = Math.floor((left + right) / 2);
+
+    // 최솟값을 찾는 조건들
+    if (nums[mid] > nums[mid + 1]) {
+      return nums[mid + 1];
+    }
+    if (nums[mid - 1] > nums[mid]) {
+      return nums[mid];
+    }
+
+    // 탐색 범위 조정
+    if (nums[mid] > nums[0]) {
+      // 최솟값은 중간점 이후에 있음
+      left = mid + 1;
+    } else {
+      // 최솟값은 중간점 이전에 있음
+      right = mid - 1;
+    }
+  }
+
+  return nums[0]; // 기본값 반환
+}