Merge branch 'DaleStudy:main' into main

Author: mike2ox

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/Chaedie.py

@@ -0,0 +1,39 @@
+"""
+(해설을 보면서 따라 풀었습니다.)
+
+Solution: graph 에서 circular 가 생기면 false, 아니면 true
+
+n: numCourses
+p: number of preRequisites
+Time: O(n + p) 
+Space: O(n + p)
+"""
+
+
+class Solution:
+    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        graph = {i: [] for i in range(numCourses)}
+        for crs, pre in prerequisites:
+            graph[crs].append(pre)
+
+        traversing = set()
+        finished = set()
+
+        def dfs(crs):
+            if crs in traversing:
+                return False
+            if crs in finished:
+                return True
+
+            traversing.add(crs)
+            for pre in graph[crs]:
+                if not dfs(pre):
+                    return False
+            traversing.remove(crs)
+            finished.add(crs)
+            return True
+
+        for crs in graph:
+            if not dfs(crs):
+                return False
+        return True

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/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;
+}
+

course-schedule/ekgns33.java

@@ -0,0 +1,44 @@
+/*
+*
+* solution : topological sort
+* tc : O(E + V)
+* sc : O(E + V)
+*
+* */
+class Solution {
+  public boolean canFinish(int numCourses, int[][] prerequisites) {
+    List<Integer>[] adj = new ArrayList[numCourses];
+    for(int i = 0 ; i < numCourses; i++) {
+      adj[i] = new ArrayList<>();
+    }
+    boolean[] v = new boolean[numCourses];
+    int[] indeg = new int[numCourses];
+    for(int[] pre : prerequisites) {
+      int src = pre[0];
+      int dst = pre[1];
+      adj[src].add(dst);
+      indeg[dst]++;
+    }
+    Queue<Integer> q = new LinkedList<>();
+    for(int i = 0; i < numCourses; i ++) {
+      if(indeg[i] == 0) {
+        q.add(i);
+        v[i] = true;
+      }
+    }
+    int cnt= 0;
+    while(!q.isEmpty()) {
+      int curNode = q.poll();
+      cnt++;
+      for(int dst : adj[curNode]) {
+        indeg[dst]--;
+        if(indeg[dst] ==0 && !v[dst]) {
+          q.add(dst);
+        }
+      }
+    }
+
+    return cnt == numCourses;
+
+  }
+}

course-schedule/imsosleepy.java

@@ -0,0 +1,40 @@
+// 사이클을 찾는 문제. DFS를 이용해서 방문했는지 여부를 관리하고 체크하면된다.
+// DFS를 진행 중인 것을 들고 있어야 사이클 여부를 판단할 수 있다.
+// 간선 수와 노드의 수에 따라 시간 복잡도가 결정됨 O(N+L)
+class Solution {
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        List<List<Integer>> graph = new ArrayList<>();
+        for (int i = 0; i < numCourses; i++) {
+            graph.add(new ArrayList<>());
+        }
+
+        for (int[] pair : prerequisites) {
+            graph.get(pair[1]).add(pair[0]);
+        }
+
+        // 0: 방문 X
+        // -1: DFS 진행 중
+        // 1: 방문 완료
+        int[] visited = new int[numCourses];
+
+        // 모든 노드에서 DFS 수행
+        for (int i = 0; i < numCourses; i++) {
+            if (dfs(graph, visited, i)) return false;
+        }
+        
+        return true;
+    }
+
+    private boolean dfs(List<List<Integer>> graph, int[] visited, int node) {
+        if (visited[node] == -1) return true;  // 방문 중이면 사이클이 발견
+        if (visited[node] == 1) return false; 
+
+        visited[node] = -1; // 진행 중 표기
+        for (int next : graph.get(node)) {
+            if (dfs(graph, visited, next)) return true;
+        }
+        visited[node] = 1;
+
+        return false;
+    }
+}

course-schedule/pmjuu.py

@@ -0,0 +1,41 @@
+'''
+시간 복잡도: O(V + E)
+- 위상 정렬(Topological Sort)을 사용하여 모든 노드(과목)와 간선(선수 과목 관계)을 탐색하므로 O(V + E)입니다.
+  - V: 노드(과목) 개수 (numCourses)
+  - E: 간선(선수 과목 관계) 개수 (prerequisites의 길이)
+
+공간 복잡도: O(V + E)
+- 그래프를 인접 리스트로 저장하는 데 O(V + E) 공간이 필요합니다.
+- 추가적으로 방문 상태를 저장하는 리스트가 필요하여 O(V).
+- 따라서 총 공간 복잡도는 O(V + E)입니다.
+'''
+
+from collections import deque
+from typing import List
+
+class Solution:
+    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        # 그래프 초기화
+        graph = {i: [] for i in range(numCourses)}
+        in_degree = {i: 0 for i in range(numCourses)}
+
+        # 선수 과목 정보 그래프에 저장
+        for course, pre in prerequisites:
+            graph[pre].append(course)
+            in_degree[course] += 1
+
+        # 진입 차수가 0인 과목(선수 과목이 없는 과목)을 큐에 추가
+        queue = deque([course for course in in_degree if in_degree[course] == 0])
+        completed_courses = 0
+
+        while queue:
+            current = queue.popleft()
+            completed_courses += 1
+
+            for neighbor in graph[current]:
+                in_degree[neighbor] -= 1
+                if in_degree[neighbor] == 0:
+                    queue.append(neighbor)
+
+        # 모든 과목을 수강할 수 있다면 True, 아니면 False
+        return completed_courses == numCourses

course-schedule/yolophg.py

@@ -0,0 +1,43 @@
+# Time Complexity: O(V + E) - visit each course once and process all edges
+# Space Complexity: O(V + E) - storing the graph + recursion stack (worst case)
+
+class Solution:
+    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+
+        # Build the adjacency list (prereq map)
+        preMap = {i: [] for i in range(numCourses)}
+        for crs, pre in prerequisites:
+            preMap[crs].append(pre)
+        
+        # tracks courses currently being checked (for cycle detection)
+        visited = set()  
+
+        def dfs(crs):
+            # found a cycle
+            if crs in visited:  
+                return False
+            # no more prereqs left
+            if preMap[crs] == []: 
+                return True
+            
+            # mark as visiting
+            visited.add(crs)  
+            
+            # check all prereqs for this course
+            for pre in preMap[crs]:
+                if not dfs(pre):
+                    # cycle detected, return False
+                    return False  
+            
+            # done checking, remove from visited
+            visited.remove(crs)  
+            # mark as completed
+            preMap[crs] = []  
+            return True
+
+        # run dfs on every course
+        for crs in range(numCourses):
+            if not dfs(crs):
+                return False
+        
+        return True