Merge branch 'DaleStudy:main' into main

Author: gitsunmin

course-schedule/HC-kang.ts

@@ -0,0 +1,34 @@
+/**
+ * https://leetcode.com/problems/course-schedule/
+ * T.C. O(V + E)
+ * S.C. O(V + E)
+ */
+function canFinish(numCourses: number, prerequisites: number[][]): boolean {
+  const graph: number[][] = Array.from({ length: numCourses }, () => []);
+  for (const [course, pre] of prerequisites) {
+    graph[pre].push(course);
+  }
+
+  const visited = new Array(numCourses).fill(false);
+  const visiting = new Array(numCourses).fill(false);
+
+  const dfs = (course: number): boolean => {
+    if (visited[course]) return true;
+    if (visiting[course]) return false;
+
+    visiting[course] = true;
+    for (const neighbor of graph[course]) {
+      if (!dfs(neighbor)) return false;
+    }
+    visiting[course] = false;
+    visited[course] = true;
+
+    return true;
+  };
+
+  for (let i = 0; i < numCourses; i++) {
+    if (!visited[i] && !dfs(i)) return false;
+  }
+
+  return true;
+}

course-schedule/flynn.go

@@ -0,0 +1,65 @@
+/*
+풀이
+- 각 course를 node로 생각하고, prerequisite 관계에 있는 node를 간선으로 이어주면 단방향 간선으로 연결된 node 집합의 graph를 떠올릴 수 있습니다
+- 이 문제는 위에서 설명한 graph에 loop가 있냐 없느냐를 판단하는 문제입니다
+- 함수의 재귀호출 및 백트래킹을 이용해서 풀이할 수 있습니다
+
+Big O
+- N: 과목 수 (node의 개수)
+- M: 배열 prerequisites의 길이 (간선의 개수)
+- Time compleixty: O(N + M)
+  - prereqMap을 초기화 -> O(M)
+  - 함수의 재귀호출을 통해 우리는 각 node를 최대 한번씩 조회합니다 -> O(N)
+- Space complexity: O(N + M)
+  - prereqMap -> O(M)
+  - checkingSet, checkedSet -> O(N)
+*/
+
+func canFinish(numCourses int, prerequisites [][]int) bool {
+	// 주어진 prerequisites 배열로 `a_i: b_0, b_1, ...` 형태의 맵을 짭니다
+	prereqMap := make(map[int][]int, numCourses)
+	for _, pair := range prerequisites {
+		prereqMap[pair[0]] = append(prereqMap[pair[0]], pair[1])
+	}
+
+	// checkingSet으로 현재 탐색하고 있는 구간에 loop가 생겼는지 여부를 판단하고, checkedSet으로 이미 탐색한 node인지를 판단합니다
+	checkingSet, checkedSet := make(map[int]bool, 0), make(map[int]bool, 0)
+
+	// 특정 과목 c를 듣기 위한 선행 과목들을 탐색했을 때 loop가 생기는지 여부를 판단하는 함수입니다
+	// (Go 언어 특성상 L:20-21 처럼 함수를 선언합니다 (함수 내부에서 함수를 선언할 땐 익명 함수를 사용 + 해당 함수를 재귀호출하기 위해서 선언과 초기화를 분리))
+	var checkLoop func(int) bool // loop가 있다면 true
+	checkLoop = func(c int) bool {
+		// 과목 c가 현재 탐색하고 있는 구간에 존재한다면 loop가 있다고 판단 내릴 수 있습니다
+		_, checkingOk := checkingSet[c]
+		if checkingOk {
+			return true
+		}
+		// 과목 c가 이미 탐색이 완료된 과목이라면 과목 c를 지나는 하위 구간에는 loop가 없다고 판단할 수 있습니다
+		_, checkedOk := checkedSet[c]
+		if checkedOk {
+			return false
+		}
+		// 과목 c를 checkingSet에 추가합니다
+		// 만약 하위 구간에서 과목 c를 다시 만난다면 loop가 있다고 판단할 수 있습니다
+		checkingSet[c] = true
+		// 각 선행과목 별로 하위구간을 만들어 탐색을 진행합니다
+		// 하위구간 중 하나라도 loop가 발생하면 현재 구간에는 loop가 있다고 판단할 수 있습니다
+		for _, prereq := range prereqMap[c] {
+			if checkLoop(prereq) {
+				return true
+			}
+		}
+		// 만약 loop가 발견되지 않았다면 checkedSet에 과목 c를 추가함으로써 과목 c를 지나는 구간이 안전하다고 표시합니다
+		checkedSet[c] = true
+		// checkingSet에서 과목 c를 지워줍니다
+		delete(checkingSet, c)
+		return false
+	}
+
+	for i := 0; i < numCourses; i++ {
+		if checkLoop(i) {
+			return false
+		}
+	}
+	return true
+}

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

@@ -0,0 +1,32 @@
+// 시간복잡도: O(log n)
+// 공간복잡도: O(1)
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findMin = function(nums) {
+    let leftIdx = 0;
+    let rightIdx = nums.length - 1;
+
+    if (nums.length === 1) return nums[0]
+
+    while (leftIdx <= rightIdx) {
+        if (nums[leftIdx] < nums[rightIdx]) return nums[leftIdx]
+
+        let midIdx = Math.floor((leftIdx + rightIdx) / 2);
+
+        if (nums[midIdx] > nums[midIdx+1]) {
+            return nums[midIdx+1]
+        }
+
+        if (nums[leftIdx] < nums[midIdx] && nums[leftIdx] > nums[rightIdx]) {
+            leftIdx = midIdx
+        } else {
+            rightIdx = midIdx
+        }
+    }
+
+    return nums[0]
+};
+

invert-binary-tree/HC-kang.ts

@@ -0,0 +1,48 @@
+// 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;
+//   }
+// }
+
+/**
+ * https://leetcode.com/problems/invert-binary-tree
+ * T.C. O(n)
+ * S.C. O(n)
+ */
+function invertTree(root: TreeNode | null): TreeNode | null {
+  if (root === null) {
+    return null;
+  }
+
+  [root.left, root.right] = [root.right, root.left];
+  invertTree(root.left);
+  invertTree(root.right);
+
+  return root;
+}
+
+/**
+ * T.C. O(n)
+ * S.C. O(n)
+ */
+function invertTree(root: TreeNode | null): TreeNode | null {
+  const stack: Array<TreeNode | null> = [root];
+
+  while (stack.length > 0) {
+    const node = stack.pop()!;
+
+    if (node === null) {
+      continue;
+    }
+
+    [node.left, node.right] = [node.right, node.left];
+    stack.push(node.left, node.right);
+  }
+
+  return root;
+}

invert-binary-tree/flynn.go

@@ -0,0 +1,77 @@
+/*
+풀이 1
+- 함수의 재귀호출을 이용해서 풀이할 수 있습니다
+
+Big O
+- N: 노드의 개수
+- H: 트리의 높이
+- Time complexity: O(N)
+- Space complexity: O(H) (logN <= H <= N)
+  - 재귀 호출 스택의 최대 깊이는 트리의 높이에 비례하여 증가합니다
+*/
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+ func invertTree(root *TreeNode) *TreeNode {
+	if root == nil {
+		return root
+	}
+
+	tmp := invertTree(root.Right)
+	root.Right = invertTree(root.Left)
+	root.Left = tmp
+
+	return root
+}
+
+/*
+풀이 2
+- 큐와 반복문을 이용하여 풀이할 수 있습니다
+
+Big O
+- N: 노드의 개수
+- Time complexity: O(N)
+- Space complexity: O(N)
+  - 큐의 최대 크기는 N / 2 를 넘지 않습니다
+    큐의 최대 크기는 트리의 모든 층 중에서 가장 폭이 큰 층의 노드 수와 같습니다
+	높이가 H인 트리의 최대 폭은 1. balanced tree일 때 2. 맨 아랫 층의 폭이고 이 때의 폭 W는 2^(H-1) 입니다
+	높이가 H인 balanced tree의 노드 개수는 2^H - 1 = N 이므로 아래 관계가 성립합니다
+	N/2 = (2^H - 1) / 2 = 2^(H-1) - 1/2 >= 2^(H-1) = W
+	따라서 공간 복잡도는 O(N/2) = O(N) 입니다
+*/
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func invertTree(root *TreeNode) *TreeNode {
+	queue := make([]*TreeNode, 0)
+	queue = append(queue, root)
+
+	for len(queue) > 0 {
+		node := queue[0]
+		queue = queue[1:]
+
+		if node == nil {
+			continue
+		}
+
+		tmp := node.Left
+		node.Left = node.Right
+		node.Right = tmp
+
+		queue = append(queue, node.Left, node.Right)
+	}
+
+	return root
+}

jump-game/HC-kang.ts

@@ -0,0 +1,16 @@
+/**
+ * https://leetcode.com/problems/jump-game/
+ * T.C. O(n)
+ * S.C. O(1)
+ */
+function canJump(nums: number[]): boolean {
+  let max = 0;
+
+  for (let i = 0; i < nums.length; i++) {
+    if (i > max) return false;
+    max = Math.max(max, i + nums[i]);
+    if (max >= nums.length - 1) return true;
+  }
+
+  return false;
+}

jump-game/flynn.go

@@ -0,0 +1,65 @@
+/*
+풀이 1
+- memo 배열을 이용하여 n-1번째 인덱스부터 0번째 인덱스 방향으로 탐색하여 풀이할 수 있습니다
+  memo[i] = i번째 인덱스에서 출발했을 때 마지막 인덱스에 도달할 수 있는지 여부
+
+Big O
+- N: 주어진 배열 nums의 길이
+- Time complexity: O(N)
+- Space complexity: O(N)
+  - 풀이 2를 이용하면 O(1)으로 최적화할 수 있습니다
+*/
+
+func canJump(nums []int) bool {
+	n := len(nums)
+
+	if nums[0] == 0 && n > 1 {
+		return false
+	}
+
+	memo := make([]bool, n)
+	memo[n-1] = true
+
+	for i := n - 2; i >= 0; i-- {
+		for j := 1; j <= nums[i]; j++ {
+			if i+j >= n {
+				break
+			}
+			if memo[i+j] {
+				memo[i] = true
+				break
+			}
+		}
+	}
+
+	return memo[0]
+}
+
+/*
+풀이
+- 풀이 1을 잘 관찰하면 memo배열의 모든 값을 가지고 있을 필요가 없다는 걸 알 수 있습니다
+  memo 배열 대신에, 문제의 조건대로 마지막 인덱스까지 갈 수 있는 가장 좌측의 인덱스만 기록합니다 (leftmost)
+
+Big O
+- N: 주어진 배열 nums의 길이
+- Time complexity: O(N)
+- Space complexity: O(1)
+*/
+
+func canJump(nums []int) bool {
+	n := len(nums)
+
+	if nums[0] == 0 && n > 1 {
+		return false
+	}
+
+	leftmost := n - 1
+
+	for i := n - 2; i >= 0; i-- {
+		if i+nums[i] >= leftmost {
+			leftmost = i
+		}
+	}
+
+	return leftmost == 0
+}

linked-list-cycle/hwanmini.js

@@ -0,0 +1,29 @@
+// 시간복잡도: O(n)
+// 공간복잡도: O(1)
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+
+/**
+ * @param {ListNode} head
+ * @return {boolean}
+ */
+var hasCycle = function(head) {
+    let fastPointer = head;
+    let slowPointer = head;
+
+    while (fastPointer && fastPointer.next) {
+        slowPointer = slowPointer.next;
+        fastPointer = fastPointer.next.next
+
+        if (fastPointer === slowPointer) return true
+
+    }
+
+    return false
+};

longest-substring-without-repeating-characters/sun912.py

@@ -0,0 +1,22 @@
+"""
+    TC: O(n)
+    SC: O(n)
+"""
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        str_list = []
+        max_length = 0
+        for i in range(len(s)):
+            if s[i] not in str_list:
+                str_list.append(s[i])
+            else:
+                if max_length < len(str_list):
+                    max_length = len(str_list)
+                str_list = str_list[str_list.index(s[i])+1:]
+                str_list.append(s[i])
+
+        if max_length < len(str_list):
+            max_length = len(str_list)
+
+        return max_length
+