Merge branch 'DaleStudy:main' into main

Author: mangodm-web

course-schedule/kayden.py

@@ -0,0 +1,33 @@
+from collections import deque
+class Solution:
+    # 시간복잡도: O(numCourses + prerequisites의 길이)
+    # 공간복잡도: O(numCourses + prerequisites의 길이)
+    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+
+        reachable = [0 for _ in range(numCourses)]
+        graph = [[] for _ in range(numCourses)]
+
+        for a, b in prerequisites:
+            reachable[a] += 1
+            graph[b].append(a)
+
+        q = deque()
+        visited = set()
+        for i in range(numCourses):
+            if reachable[i] == 0:
+                q.append(i)
+                visited.add(i)
+
+        while q:
+            node = q.popleft()
+
+            for next_node in graph[node]:
+                reachable[next_node] -= 1
+                if next_node not in visited and reachable[next_node] == 0:
+                    q.append(next_node)
+                    visited.add(next_node)
+
+        if len(visited) == numCourses:
+            return True
+
+        return False

course-schedule/wogha95.js

@@ -0,0 +1,49 @@
+/**
+ * TC: O(V + E)
+ * SC: O(V + E)
+ * N: numCourses(all of vertex), P: prerequisites(all of edge)
+ */
+
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {boolean}
+ */
+var canFinish = function (numCourses, prerequisites) {
+  const STEP = {
+    before: 0,
+    ing: 1,
+    after: 2,
+  };
+  const stepBoard = Array.from({ length: numCourses }, () => STEP.before);
+  const board = Array.from({ length: numCourses }, () => []);
+
+  for (const [a, b] of prerequisites) {
+    board[a].push(b);
+  }
+
+  for (let index = 0; index < numCourses; index++) {
+    if (isCycle(index)) {
+      return false;
+    }
+  }
+  return true;
+
+  function isCycle(current) {
+    if (stepBoard[current] === STEP.end) {
+      return false;
+    }
+    if (stepBoard[current] === STEP.ing) {
+      return true;
+    }
+
+    stepBoard[current] = STEP.ing;
+    for (const next of board[current]) {
+      if (isCycle(next)) {
+        return true;
+      }
+    }
+    stepBoard[current] = STEP.end;
+    return false;
+  }
+};

invert-binary-tree/gitsunmin.ts

@@ -0,0 +1,34 @@
+/**
+ * https://leetcode.com/problems/invert-binary-tree/
+ * time complexity : O(n)
+ * space complexity : O(log N)
+ */
+
+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)
+    }
+}
+
+export const dfs = (root: TreeNode | null, inverted: TreeNode | null): TreeNode | null => {
+    if (!root) return null;
+
+    const left = dfs(root.left, inverted);
+    const right = dfs(root.right, inverted);
+
+    root.left = right;
+    root.right = left;
+
+    return root;
+};
+
+function invertTree(root: TreeNode | null): TreeNode | null {
+    if (!root) return null;
+
+    return dfs(root, new TreeNode(0));
+};

invert-binary-tree/kayden.py

@@ -0,0 +1,19 @@
+class Solution:
+    # 시간복잡도: O(N)
+    # 공간복잡도: O(1)
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        def invert(node):
+            if not node:
+                return
+
+            r = invert(node.left)
+            l = invert(node.right)
+
+            node.right = r
+            node.left = l
+
+            return node
+
+        invert(root)
+
+        return root

invert-binary-tree/wogha95.js

@@ -0,0 +1,33 @@
+/**
+ * 양쪽 자식 노드 주소를 교환하고 dfs로 순회합니다.
+ *
+ * TC: O(N)
+ * 모든 트리를 순회합니다.
+ *
+ * SC: O(N)
+ * 최악의 경우 (한쪽으로 치우친 트리) N만큼 CallStack이 생깁니다.
+ *
+ * N: tree의 모든 node 수
+ */
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+var invertTree = function (root) {
+  if (!root) {
+    return root;
+  }
+  [root.left, root.right] = [root.right, root.left];
+  invertTree(root.left);
+  invertTree(root.right);
+  return root;
+};

jump-game/kayden.py

@@ -0,0 +1,15 @@
+class Solution:
+    # 시간복잡도: O(N)
+    # 공간복잡도: O(1)
+    # 이 문제는 마지막 테케가 통과하지 않아서 답을 참고했습니다.
+    def canJump(self, nums: List[int]) -> bool:
+
+        gas = 0
+        for n in nums:
+            if gas < 0:
+                return False
+            elif n > gas:
+                gas = n
+            gas -= 1
+
+        return True

jump-game/wogha95.js

@@ -0,0 +1,37 @@
+/**
+ * TC: O(N)
+ * SC: O(1)
+ * N: nums.length
+ */
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var canJump = function (nums) {
+  if (nums.length === 1) {
+    return true;
+  }
+
+  let maximumIndex = 0;
+
+  for (let index = 0; index < nums.length; index++) {
+    const jumpLength = nums[index];
+
+    if (jumpLength === 0) {
+      continue;
+    }
+
+    if (maximumIndex < index) {
+      return false;
+    }
+
+    maximumIndex = Math.max(maximumIndex, index + nums[index]);
+
+    if (maximumIndex >= nums.length - 1) {
+      return true;
+    }
+  }
+
+  return false;
+};

merge-k-sorted-lists/kayden.py

@@ -0,0 +1,41 @@
+class Solution:
+    # 시간복잡도: O(NlogK) N: 모든 리스트의 노드 수 합 K: 리스트의 개수
+    # 공간복잡도: O(1) 기존 노드 재활용
+    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
+        if not lists: return None
+        if len(lists) == 1: return lists[0]
+
+        def merge(a, b):
+            res = ListNode()
+            cur = res
+
+            while a and b:
+                if a.val > b.val:
+                    cur.next = b
+                    b = b.next
+                else:
+                    cur.next = a
+                    a = a.next
+                cur = cur.next
+
+            if a:
+                cur.next = a
+            else:
+                cur.next = b
+
+            return res.next
+
+        def mergeK(lo, hi):
+            if lo == hi:
+                return lists[lo]
+
+            if hi - lo == 1:
+                return merge(lists[lo], lists[hi])
+
+            mid = (lo + hi) // 2
+            left = mergeK(lo, mid)
+            right = mergeK(mid+1, hi)
+
+            return merge(left, right)
+
+        return mergeK(0, len(lists)-1)

search-in-rotated-sorted-array/kayden.py

@@ -0,0 +1,22 @@
+class Solution:
+    # 시간복잡도: O(logN)
+    # 공간복잡도: O(1)
+    def search(self, nums: List[int], target: int) -> int:
+        n = len(nums)
+        st, en = 0, n-1
+        while st <= en:
+            mid = (st+en)//2
+            if nums[mid] == target:
+                return mid
+            elif nums[mid] >= nums[st]:
+                if nums[st] <= target <= nums[mid]:
+                    en = mid - 1
+                else:
+                    st = mid + 1
+            else:
+                if nums[mid] <= target <= nums[en]:
+                    st = mid + 1
+                else:
+                    en = mid - 1
+
+        return -1

search-in-rotated-sorted-array/wogha95.js

@@ -0,0 +1,65 @@
+/**
+ * 모든 케이스가 많지 않다고 생각되어 분기처리하였습니다..
+ * 더 간결한 풀이법을 고려해보는 중..
+ *
+ * TC: O(log N)
+ * 이진탐색을 이용하여 순회합니다.
+ *
+ * SC: O(1)
+ * 이진탐색에 이용되는 투 포인터의 공간복잡도를 갖습니다.
+ */
+
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var search = function (nums, target) {
+  if (nums.length === 1) {
+    return target === nums[0] ? 0 : -1;
+  }
+
+  let left = 0;
+  let right = nums.length - 1;
+
+  while (left < right) {
+    const center = Math.floor((left + right) / 2);
+    if (target === nums[left]) {
+      return left;
+    }
+    if (target === nums[center]) {
+      return center;
+    }
+    if (target === nums[right]) {
+      return right;
+    }
+
+    if (nums[left] <= nums[center] && nums[center] < nums[right]) {
+      if (target < nums[left] || nums[right] < target) {
+        return -1;
+      } else if (nums[left] < target && target < nums[center]) {
+        right = center;
+      } else if (nums[center] < target && target < nums[right]) {
+        left = center + 1;
+      }
+    } else if (nums[right] < nums[left] && nums[left] <= nums[center]) {
+      if (nums[right] < target && target < nums[left]) {
+        return -1;
+      } else if (nums[left] < target && target < nums[center]) {
+        right = center;
+      } else {
+        left = center + 1;
+      }
+    } else if (nums[center] < nums[right] && nums[right] < nums[left]) {
+      if (nums[center] < target && target < nums[right]) {
+        left = center + 1;
+      } else if (nums[right] < target && target < nums[left]) {
+        return -1;
+      } else {
+        right = center;
+      }
+    }
+  }
+
+  return -1;
+};