Merge branch 'main' of https://github.com/Chaedie/leetcode-study

# Please enter a commit message to explain why this merge is necessary,
# especially if it merges an updated upstream into a topic branch.
#
# Lines starting with '#' will be ignored, and an empty message aborts
# the commit.

Author: Chaedie

binary-tree-maximum-path-sum/jdy8739.js

@@ -0,0 +1,36 @@
+/**
+ * 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 {number}
+ */
+var maxPathSum = function(root) {
+    let max = root.val;
+
+    const dfs = (node) => {
+        if (!node) {
+            return 0;
+        }
+
+        const left = Math.max(dfs(node.left), 0);
+        const right = Math.max(dfs(node.right), 0);
+        const sum = node.val + left + right;
+
+        max = Math.max(sum, max);
+
+        return node.val + Math.max(left, right);
+    }
+
+    dfs(root);
+
+    return max;
+};
+
+// 시간복잡도 O(n) -> 트리의 모든 노드를 재귀적으로 탐색하므로 복잡도는 노드의 수와 비례함
+// 공간복잡도 O(h) -> 입력된 트리의 최대 높이만큼 재귀 스택이 쌓이므로 공간복잡도는 트리의 높이와 같음

course-schedule/Jeehay28.js

@@ -0,0 +1,69 @@
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {boolean}
+ */
+
+// ✅ Graph DFS (Depth-First Search) approach
+// Time Complexity: O(V + E), where V is the number of courses (numCourses) and E is the number of prerequisites (edges).
+// Space Complexity: O(V + E), where V is the number of courses and E is the number of prerequisites.
+
+var canFinish = function (numCourses, prerequisites) {
+  // prerequisites = [
+  // [1, 0], // Course 1 depends on Course 0
+  // [2, 1], // Course 2 depends on Course 1
+  // [3, 1], // Course 3 depends on Course 1
+  // [3, 2]  // Course 3 depends on Course 2
+  // ];
+
+  // graph = {
+  // 0: [1], // Course 0 is a prerequisite for Course 1
+  // 1: [2, 3], // Course 1 is a prerequisite for Courses 2 and 3
+  // 2: [3], // Course 2 is a prerequisite for Course 3
+  // 3: [] // Course 3 has no prerequisites
+  // };
+
+  // Build the graph
+  const graph = {};
+
+  // for(let i=0; i<numCourses; i++) {
+  //     graph[i] = []
+  // }
+
+  // Fill in the graph with prerequisites
+  for (const [course, prereq] of prerequisites) {
+    if (!graph[prereq]) {
+      graph[prereq] = [];
+    }
+    graph[prereq].push(course);
+  }
+
+  const visited = new Array(numCourses).fill(0);
+
+  const dfs = (course) => {
+    if (visited[course] === 1) return false; // cycle detected!
+    if (visited[course] === 2) return true; // already visited
+
+    visited[course] = 1;
+
+    // // Visit all the courses that depend on the current course
+    for (const nextCourse of graph[course] || []) {
+      if (!dfs(nextCourse)) {
+        return false; // cycle detected!
+      }
+    }
+
+    visited[course] = 2; // fully visited and return true
+    return true;
+  };
+
+  // Check for each course whether it's possible to finish it
+  for (let i = 0; i < numCourses; i++) {
+    if (!dfs(i)) {
+      return false; // cycle detected!
+    }
+  }
+
+  return true; // no cycles
+};
+

course-schedule/KwonNayeon.py

@@ -0,0 +1,57 @@
+"""
+Constraints:
+- 1 <= numCourses <= 2000
+- 0 <= prerequisites.length <= 5000
+- prerequisites[i].length == 2
+- 0 <= ai, bi < numCourses
+- All the pairs prerequisites[i] are unique.
+
+Time Complexity: O(N + P) 
+- N: numCourses, P: prerequisites의 길이
+
+Space Complexity: O(N + P) 
+- 세트의 메모리 사용량이 N과 비례하고 인접 리스트의 크기가 P
+- 재귀 호출 스택의 깊이는 최악의 경우 O(N)
+
+풀이방법:
+1. prerequisites을 directed graph로 변환
+  - 각 코스별로 선수과목의 리스트를 저장함
+2. DFS를 사용하여 cycle 존재 여부 확인
+  - visited 배열: 이미 확인이 완료된 노드 체크
+  - path 배열: 현재 DFS 경로에서 방문한 노드 체크
+3. cycle이 발견되면 false, 그렇지 않으면 true 반환
+  - 현재 경로에서 이미 방문한 노드를 다시 만나면 cycle 있음
+  - 모든 노드 방문이 가능하면 cycle 없음
+"""
+class Solution:
+   def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+       graph = [[] for _ in range(numCourses)]
+       for course, prereq in prerequisites:
+           graph[course].append(prereq)
+       
+       visited = [False] * numCourses
+       path = [False] * numCourses
+       
+       def dfs(course):
+           if path[course]:
+               return False
+           if visited[course]:
+               return True
+               
+           path[course] = True
+           
+           for prereq in graph[course]:
+               if not dfs(prereq):
+                   return False
+                   
+           path[course] = False
+           visited[course] = True
+           
+           return True
+       
+       for course in range(numCourses):
+           if not dfs(course):
+               return False
+       
+       return True
+

course-schedule/Yjason-K.ts

@@ -0,0 +1,61 @@
+
+/**
+ * 선수 과목과 이수 과목 관계를 확인하여 모든 과목을 이수할 수 있는지 여부 확인.
+ * @param {number} numCourses - 전체 과목 수
+ * @param {number[][]} prerequisites - 선수 과목과 이수 과목 관계 정보
+ * @returns {boolean} - 모든 과목을 수강할 수 있는지 여부
+ * 
+ * 시간 복잡도: O(V + E)
+ *  - 그래프를 생성하는 과정에서 O(E),
+ *  - bfs O(V + E),
+ * 
+ * 공간 복잡도: O(V + E)
+ *  - 각 과목에 대한 선수 과목 저장에 O(V + E),
+ *  - prereqCount 저장에 O(V),
+ *  - 큐(queue) 저장에 O(V),
+ */
+function canFinish(numCourses: number, prerequisites: number[][]): boolean {
+    // 각 과목의 선수 과목 정보를 저장하는 리스트
+    const graph: number[][] = Array.from({ length: numCourses }, () => []);
+    // 각 과목의 선수 과목 수 를 저장하는 배열
+    const prereqCount: number[] = new Array(numCourses).fill(0);
+    
+    // 그래프 및 선수 과목 개수 초기화
+    for (const [course, prereq] of prerequisites) {
+        graph[prereq].push(course); // 선수 과목을 들어야 수강 가능한 과목 추가
+        prereqCount[course]++; // 해당 과목의 선수 과목 개수 증가
+    }
+    
+    // 선수 과목이 없는 과목들을 저장할 큐
+    const queue: number[] = [];
+    
+    // 선수 과목이 없는 과목들을 큐에 추가 (진입 차수가 0인 노드)
+    for (let i = 0; i < numCourses; i++) {
+        if (prereqCount[i] === 0) {
+            queue.push(i);
+        }
+    }
+    
+    // 수강한 과목 수
+    let completedCourses = 0;
+    
+    // 선수 과목이 없는 과목을 사용해서 다음 과목을 수강
+    while (queue.length > 0) {
+        const current = queue.shift()!;
+        completedCourses++; // 과목 수강 완료
+        
+        // 현재 과목을 선수 과목으로 하는 다른 과목들의 선수 과목 개수 감소
+        for (const nextCourse of graph[current]) {
+            prereqCount[nextCourse]--;
+            
+            // 선수 과목 개수가 0이 되면 큐에 추가 (더 이상 기다릴 필요 없음)
+            if (prereqCount[nextCourse] === 0) {
+                queue.push(nextCourse);
+            }
+        }
+    }
+    
+    // 모든 과목을 수강 수 있는지 확인
+    return completedCourses === numCourses;
+}
+