Merge branch 'DaleStudy:main' into main

Author: jdy8739

course-schedule/eunhwa99.java

@@ -0,0 +1,45 @@
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+class Solution {
+
+  // TC: O(numCourses + E) E는 prerequisites 배열의 길이 (즉, 간선의 개수).
+  // SC: O(numCourses + E)
+  public boolean canFinish(int numCourses, int[][] prerequisites) {
+    int[] inDegree = new int[numCourses];
+    List<List<Integer>> adj = new ArrayList<>();
+
+    for (int i = 0; i < numCourses; i++) {
+      adj.add(new ArrayList<>());
+    }
+
+    for (int[] pre : prerequisites) {
+      adj.get(pre[1]).add(pre[0]);
+      inDegree[pre[0]]++;
+    }
+
+    Queue<Integer> queue = new LinkedList<>();
+    for (int i = 0; i < numCourses; i++) {
+      if (inDegree[i] == 0) {
+        queue.add(i);
+      }
+    }
+    for (int i = 0; i < numCourses; i++) {
+      if (queue.isEmpty()) {
+        return false;
+      }
+      int course = queue.poll();
+
+      for (int nextCourse : adj.get(course)) {
+        inDegree[nextCourse]--;
+        if (inDegree[nextCourse] == 0) {
+          queue.add(nextCourse);
+        }
+      }
+    }
+    return queue.isEmpty();
+  }
+}
+

course-schedule/mmyeon.ts

@@ -0,0 +1,62 @@
+/**
+ * @link https://leetcode.com/problems/course-schedule/description/
+ *
+ * 접근 방법 :
+ *  - 주어진 과목에서 선수 과목 사이클이 존재하는지 확인하기 위해서 dfs 사용
+ *  - 사이클이 있다는 건 탐색 중에 다시 동일 과목이 등장한 경우니까, 과목별 결과 저장하기 위해서 visited 배열 사용
+ *
+ * 시간복잡도 : O(n + e)
+ *  - n = 들어야 하는 과목 수
+ *  - e = 선수 과목과 연결된 과목 수
+ *  - 선수 과목 dfs 호출하고, 선수 과목과 연결된 과목도 호출함
+ *
+ * 공간복잡도 : O(n + e)
+ *  - n = 들어야 하는 과목 수
+ *  - e = 선수 과목과 연결된 과목 수
+ *  - visited 배열 : O(n)
+ *  - Map : O(e)
+ */
+
+function canFinish(numCourses: number, prerequisites: number[][]): boolean {
+  // 선수 과목을 키, 후속 과목을 값으로 저장
+  const map = new Map<number, number[]>();
+
+  for (const [course, prerequisite] of prerequisites) {
+    if (!map.has(prerequisite)) map.set(prerequisite, []);
+    map.get(prerequisite)!.push(course);
+  }
+
+  // 이미 탐색중인 과목인지 확인하기 위한 배열
+  // 미탐색 : 0, 탐색중: 1, 탐색완료 : 2로 처리
+  const visited = Array(numCourses).fill(0);
+
+  const dfs = (course: number) => {
+    // 탐색중이면 사이클이 발생
+    if (visited[course] === 1) return false;
+    // 탐색 완료인 과목은 사이클이 없는 상태니까 true 리턴
+    if (visited[course] === 2) return true;
+
+    // 탐색 시작
+    // 탐색 중인 상태로 변경
+    visited[course] = 1;
+
+    const nextCourses = map.get(course) ?? [];
+
+    // 후속 과목 모두 체크
+    for (const nextCourse of nextCourses) {
+      if (!dfs(nextCourse)) return false;
+    }
+
+    // 탐색 완료 상태로 변경
+    visited[course] = 2;
+    return true;
+  };
+
+  // 들어야 하는 모든 과목에 대해 dfs 호출
+  for (let i = 0; i < numCourses; i++) {
+    // 미탐색 노드만 탐색하도록 처리
+    if (visited[i] === 0 && !dfs(i)) return false;
+  }
+
+  return true;
+}

invert-binary-tree/bus710.go

@@ -0,0 +1,31 @@
+package hello
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func invertTree(root *TreeNode) *TreeNode {
+	if root == nil {
+		return root
+	}
+
+	visit(root)
+
+	return root
+}
+
+func visit(node *TreeNode) {
+	if node.Left != nil {
+		visit(node.Left)
+	}
+	if node.Right != nil {
+		visit(node.Right)
+	}
+
+	// Swap
+	tmp := node.Left
+	node.Left = node.Right
+	node.Right = tmp
+}

invert-binary-tree/eunhwa99.java

@@ -0,0 +1,21 @@
+class Solution {
+
+  // TC : O(N)
+  // SC : O(1)
+  public TreeNode invertTree(TreeNode root) {
+    if (root == null) {
+      return null;
+    }
+
+    TreeNode tmp = root.left;
+    root.left = root.right;
+    root.right = tmp;
+
+    invertTree(root.right);
+    invertTree(root.left);
+
+    return root;
+  }
+
+}
+

invert-binary-tree/mike2ox.ts

@@ -0,0 +1,36 @@
+/**
+ * Source: https://leetcode.com/problems/invert-binary-tree/
+ * 풀이방법: 재귀를 이용하여 트리를 뒤집음
+ *
+ * 시간복잡도: O(n) - n은 트리의 노드 수
+ * 공간복잡도: O(n) - 재귀 호출에 따른 스택 메모리
+ *
+ * 다른 풀이방법
+ * - BFS를 이용하여 풀이
+ * - 스택을 이용하여 풀이
+ */
+
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+function invertTree(root: TreeNode | null): TreeNode | null {
+  if (!root) return null;
+
+  const result = new TreeNode(
+    root.val,
+    invertTree(root.right),
+    invertTree(root.left)
+  );
+  return result;
+}

invert-binary-tree/mmyeon.ts

@@ -0,0 +1,63 @@
+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;
+  }
+}
+
+/**
+ * @link https://leetcode.com/problems/invert-binary-tree/description/
+ *
+ * 접근 방법 : 깊이 우선 탐색(DFS) 사용
+ * - 각 노드의 좌우 자식 노드 swap 진행
+ * - 왼쪽, 오른쪽 서브트리에 대해 재귀적으로 호출
+ *
+ * 시간복잡도 : O(n)
+ *  - n은 노드의 개수, 주어진 노드 만큼 순회
+ *
+ * 공간복잡도 : O(h)
+ *  - h : 트리의 높이
+ *  - 호출 스택 최대 트리 높이만큼 쌓임
+ */
+function invertTree(root: TreeNode | null): TreeNode | null {
+  if (!root) return root;
+
+  [root.left, root.right] = [root.right, root.left];
+  invertTree(root.left);
+  invertTree(root.right);
+
+  return root;
+}
+
+/**
+ *
+ * 접근 방법 : 너비 우선 탐색(BFS) 사용
+ * - root 노드를 큐에 담고, 큐가 빌 때까지 좌우 자식 노드 swap과 큐에 추가 하는 로직 반복하기
+ *
+ * 시간복잡도 : O(n)
+ * - n: 트리 노드의 개수
+ * - 모든 노드를 한 번 씩 방문하고 swap 작업 진행
+ *
+ * 공간복잡도 : O(n)
+ *  - 최악의 경우 치우친 트리인 경우 모든 노드 순차적으로 큐에 저장
+ */
+function invertTree(root: TreeNode | null): TreeNode | null {
+  if (!root) return root;
+
+  const queue = [root];
+
+  while (queue.length) {
+    const node = queue.shift()!;
+
+    [node.left, node.right] = [node.right, node.left];
+
+    if (node.left) queue.push(node.left);
+    if (node.right) queue.push(node.right);
+  }
+
+  return root;
+}

jump-game/eunhwa99.java

@@ -0,0 +1,14 @@
+class Solution {
+
+  public boolean canJump(int[] nums) {
+    int furthestIndex = 0;
+    for (int i = 0; i < nums.length; i++) {
+      if (furthestIndex < i) {
+        return false;
+      }
+
+      furthestIndex = Math.max(furthestIndex, i + nums[i]);
+    }
+    return true;
+  }
+}

jump-game/mike2ox.ts

@@ -0,0 +1,21 @@
+/**
+ * Source: https://leetcode.com/problems/jump-game/
+ * 풀이방법: 그리디로 접근
+ *
+ * 시간복잡도: O(n) - nums의 요소들을 다 방문할 수 있음
+ * 공간복잡도: O(1) - 특정 위치만 기억해둘 필요가 있음
+ *
+ * 다른 풀이
+ * - DFS로 처음에 접근했으나 시간 오버로 인해 Fail
+ */
+
+function canJump(nums: number[]): boolean {
+  let goal = nums.length - 1;
+  for (let i = nums.length - 1; i >= 0; i--) {
+    const pos = nums[i];
+    if (pos + i >= goal) {
+      goal = i;
+    }
+  }
+  return goal === 0;
+}

jump-game/mmyeon.ts

@@ -0,0 +1,28 @@
+/**
+ *@link https://leetcode.com/problems/jump-game/description/
+ *
+ * 접근 방법 :
+ *  - 현재 인덱스에서 최대로 도달할 수 있는 인덱스를 갱신하여 마지막 인덱스에 도달할 수 있는지 체크
+ *  - 최대 도달할 수 있는 인덱스가 현재 인덱스보다 작으면, 이후는 확인할 필요 없으니까 false 리턴
+ *
+ * 시간복잡도 : O(n)
+ *  - n = 배열의 길이, 배열 1회만 순회
+ *
+ * 공간복잡도 : O(1)
+ *  - 고정된 변수만 사용
+ */
+
+function canJump(nums: number[]): boolean {
+  const lastIndex = nums.length - 1;
+  let maxReachableIndex = 0;
+
+  for (let i = 0; i < nums.length; i++) {
+    if (maxReachableIndex < i) return false;
+
+    maxReachableIndex = Math.max(maxReachableIndex, i + nums[i]);
+
+    if (lastIndex <= maxReachableIndex) return true;
+  }
+
+  return false;
+}

merge-k-sorted-lists/eunhwa99.java

@@ -0,0 +1,35 @@
+import java.util.PriorityQueue;
+
+/**
+ * Definition for singly-linked list. public class ListNode { int val; ListNode next; ListNode() {}
+ * ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val;
+ * this.next = next; } }
+ */
+
+// TC : PQ -> O(NlogN)
+  // SC: Linked list -> O(N)
+class Solution {
+
+  public ListNode mergeKLists(ListNode[] lists) {
+    if (lists == null || lists.length == 0) {
+      return null;
+    }
+    PriorityQueue<Integer> pq = new PriorityQueue<>();
+
+    for (int i = 0; i < lists.length; i++) {
+      while (lists[i] != null) {
+        pq.add(lists[i].val);
+        lists[i] = lists[i].next;
+      }
+    }
+    ListNode dummy = new ListNode(0);
+    ListNode current = dummy;
+    while (!pq.isEmpty()) {
+      current.next = new ListNode(pq.poll());
+      current = current.next;
+    }
+
+    return dummy.next;
+  }
+}
+