Merge branch 'DaleStudy:main' into main

Author: KwonNayeon

clone-graph/taurus09318976.py

@@ -0,0 +1,79 @@
+"""
+문제의 핵심 포인트:
+각 노드는 값과 이웃 노드들의 리스트를 가짐
+원본 그래프와 완전히 독립적인 새로운 그래프 생성
+모든 연결 관계를 그대로 복사
+
+해결 방법:
+DFS(깊이 우선 탐색) + 해시맵을 사용함:
+해시맵으로 원본 노드와 복사본 노드의 매핑 관계 저장
+DFS로 그래프를 순회하면서 각 노드를 복사
+이미 복사된 노드는 해시맵에서 찾아서 재사용
+
+Example 1의 경우
+1 --- 2
+|     |
+|     |
+4 --- 3
+
+실행 과정:
+노드 1 복사: clone_1 생성, visited = clone_1
+노드 1의 이웃 2 복사: clone_2 생성, visited = clone_2
+노드 2의 이웃 1 처리: 이미 visited에 있으므로 clone_1 반환
+노드 2의 이웃 3 복사: clone_3 생성, visited = clone_3
+노드 3의 이웃들 처리: clone_2, clone_4 연결
+노드 1의 이웃 4 복사: clone_4 생성, visited = clone_4
+모든 연결 관계 완성
+Output: 원본과 동일한 구조의 완전히 새로운 그래프
+
+시간 복잡도: O(V + E)
+V: 노드(정점)의 개수, E: 간선의 개수
+각 노드를 한 번씩 방문하고, 각 간선을 한 번씩 처리
+DFS의 표준 시간 복잡도
+
+공간 복잡도: O(V)
+visited 해시맵이 모든 노드를 저장: O(V)
+DFS 재귀 호출 스택의 최대 깊이: O(V)
+복사된 그래프 자체도 O(V + E)의 공간 필요
+"""
+
+from typing import Optional
+class Solution:
+    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
+        # 빈 그래프인 경우 None 반환
+        if not node:
+            return None
+        
+        # 원본 노드를 키로, 복사본 노드를 값으로 하는 해시맵 생성
+        # 중복 복사를 방지하고 순환 참조 문제 해결
+        visited = {}
+        
+        # DFS 함수 정의
+        def dfs(original_node):
+            # 이미 복사된 노드라면 기존 복사본을 반환 (중복 복사 방지)
+            if original_node in visited:
+                return visited[original_node]
+            
+            # 원본 노드의 값으로 새로운 노드 생성
+            # 이웃 리스트는 빈 리스트로 초기화
+            clone_node = Node(original_node.val, [])
+            
+            # 해시맵에 원본-복사본 매핑 관계 저장
+            # 순환 참조 방지를 위해 이웃을 처리하기 전에 먼저 저장
+            visited[original_node] = clone_node
+            
+            # 원본 노드의 모든 이웃들을 재귀적으로 복사
+            # 복사된 이웃 노드들을 현재 복사본의 이웃 리스트에 추가
+            for neighbor in original_node.neighbors:
+                # 이웃 노드를 복사하고 현재 노드의 이웃 리스트에 추가
+                clone_node.neighbors.append(dfs(neighbor))
+            
+            # 완성된 복사본 노드 반환
+            return clone_node
+        
+        # 주어진 노드부터 DFS 시작
+        return dfs(node)
+
+
+
+

course-schedule/HoonDongKang.ts

@@ -0,0 +1,42 @@
+/**
+ * [Problem]: [207] Course Schedule
+ * (https://leetcode.com/problems/course-schedule/description/)
+ */
+
+function canFinish(numCourses: number, prerequisites: number[][]): boolean {
+    // 시간복잡도 O(n+m)
+    // 공간복잡도 O(n+m)
+    function graphFunc(numCourses: number, prerequisites: number[][]): boolean {
+        const graph: number[][] = Array.from({ length: numCourses }, () => []);
+
+        for (const [course, prerequisite] of prerequisites) {
+            graph[prerequisite].push(course);
+        }
+
+        let traversing = new Array(numCourses).fill(false);
+        let visited = new Array(numCourses).fill(false);
+
+        function dfs(course: number): boolean {
+            if (traversing[course]) return false;
+            if (visited[course]) return true;
+
+            traversing[course] = true;
+            for (let pre of graph[course]) {
+                if (!dfs(pre)) {
+                    return false;
+                }
+            }
+
+            traversing[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/Jeehay28.ts

@@ -0,0 +1,46 @@
+// TC: O(V + E), V = numCourses, E = prerequisites.length
+// SC: O(V + E)
+
+function canFinish(numCourses: number, prerequisites: number[][]): boolean {
+  // 0: [1]
+  // 1: []
+
+  const graph = new Map<number, number[]>();
+
+  // Initialize all courses
+  for (let i = 0; i < numCourses; i++) {
+    graph.set(i, []);
+  }
+
+  // Build the graph
+  for (const [crs, pre] of prerequisites) {
+    graph.get(crs)!.push(pre);
+  }
+
+  const traversing = new Set<number>();
+  const finished = new Set<number>();
+
+  const dfs = (crs: number): boolean => {
+    if (traversing.has(crs)) return false; // cycle detected
+
+    if (finished.has(crs)) return true; // already visited
+
+    traversing.add(crs);
+
+    for (const pre of graph.get(crs)!) {
+      if (!dfs(pre)) return false;
+    }
+
+    traversing.delete(crs);
+    finished.add(crs);
+
+    return true;
+  };
+
+  for (const crs of graph.keys()) {
+    if (!dfs(crs)) return false;
+  }
+
+  return true;
+}
+

course-schedule/PDKhan.cpp

@@ -0,0 +1,80 @@
+//DFS
+class Solution {
+    public:
+        bool dfs(int curr, vector<vector<int>>& graph, vector<int>& visited){
+            if(visited[curr] == 1)
+                return false;
+            
+            if(visited[curr] == 2)
+                return true;
+    
+            visited[curr] = 1;
+    
+            for(int i = 0; i < graph[curr].size(); i++){
+                if(dfs(graph[curr][i], graph, visited) == false)
+                    return false;
+            }
+    
+            visited[curr] = 2;
+    
+            return true;
+        }
+    
+        bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
+            vector<vector<int>> graph (numCourses);
+            vector<int> visited (numCourses, 0);
+    
+            for(int i = 0; i < prerequisites.size(); i++){
+                int course = prerequisites[i][0];
+                int pre = prerequisites[i][1];
+    
+                graph[pre].push_back(course);
+            }
+    
+            for(int i = 0; i < numCourses; i++){
+                if(dfs(i, graph, visited) == false)
+                    return false;
+            }
+    
+            return true;
+        }
+    };
+
+// BFS
+class Solution {
+    public:
+        bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
+            vector<vector<int>> graph (numCourses);
+            vector<int> inDegree (numCourses, 0);
+    
+            for(int i = 0; i < prerequisites.size(); i++){
+                int course = prerequisites[i][0];
+                int pre = prerequisites[i][1];
+    
+                graph[pre].push_back(course);
+                inDegree[course]++;
+            }
+    
+            queue<int> q;
+    
+            for(int i = 0; i < numCourses; i++){
+                if(inDegree[i] == 0)
+                    q.push(i);
+            }
+    
+            int count = 0;
+    
+            while(!q.empty()){
+                int curr = q.front();
+                q.pop();
+                count++;
+    
+                for(int i = 0; i < graph[curr].size(); i++){
+                    if(--inDegree[graph[curr][i]] == 0)
+                        q.push(graph[curr][i]);
+                }
+            }
+    
+            return count == numCourses;;
+        }
+    };

course-schedule/Tessa1217.java

@@ -0,0 +1,97 @@
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+class Solution {
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        // return BFS(numCourses, prerequisites);
+        return DFS(numCourses, prerequisites);
+    }
+
+    // BFS 방식으로 풀이
+    private boolean BFS(int numCourses, int[][] prerequisites) {
+
+        // 연결 그래프 생성
+        List<List<Integer>> graph = new ArrayList<>();
+        for (int i = 0; i < numCourses; i++) {
+            graph.add(new ArrayList<>());
+        }
+
+        // 들어오는 간선의 수 배열
+        int[] inDegree = new int[numCourses];
+
+        for (int[] pre : prerequisites) {
+            int course = pre[0];
+            int prereq = pre[1];
+            inDegree[course]++;
+            graph.get(prereq).add(course);
+        }
+
+        // 들어오는 간선이 없는 과목 Queue에 삽입
+        Queue<Integer> q = new LinkedList<>();
+        for (int i = 0; i < inDegree.length; i++) {
+            if (inDegree[i] == 0) {
+                q.offer(i);
+            }
+        }
+
+        // 들은 과목 수
+        int takeCourse = 0;
+        while (!q.isEmpty()) {
+            int course = q.poll();
+            takeCourse++;
+
+            for (int connect : graph.get(course)) {
+                inDegree[connect]--;
+                if (inDegree[connect] == 0) {
+                    q.offer(connect);
+                }
+            }
+        }
+
+        return takeCourse == numCourses;
+    }
+
+    // DFS 방식 풀이
+    private boolean DFS(int numCourses, int[][] prerequisites) {
+        List<List<Integer>> graph = new ArrayList<>();
+        for (int i = 0; i < numCourses; i++) {
+            graph.add(new ArrayList<>());
+        }
+
+        for (int[] pre : prerequisites) {
+            int course = pre[0];
+            int prereq = pre[1];
+            graph.get(prereq).add(course);
+        }
+
+        // 처리 상태 배열
+        int[] state = new int[numCourses];
+
+        for (int i = 0; i < numCourses; i++) {
+            if (hasCycle(graph, state, i)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    // 사이클 여부 확인
+    private boolean hasCycle(List<List<Integer>> graph, int[] state, int course) {
+
+        if (state[course] == 1) return true; // 사이클이 있다면
+        if (state[course] == 2) return false; // 이미 처리 완료되었으므로 return
+
+        state[course] = 1;
+        for (int connect : graph.get(course)) {
+            if (hasCycle(graph, state, connect)) {
+                return true;
+            }
+        }
+        state[course] = 2; // 처리 완료
+        return false;
+    }
+}
+

course-schedule/ayosecu.py

@@ -0,0 +1,44 @@
+from typing import List
+from collections import defaultdict, deque
+
+class Solution:
+    """
+        - Time Complexity: O(N + P), N = numCourses, P = len(prerequisites) 
+        - Space Complexity: O(N + P)
+    """
+    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        # Topology Sort
+        # BFS based, ingress count, visited
+        ingress_cnt = [0] * numCourses
+        dic = defaultdict(list)
+
+        for dst, src in prerequisites:
+            ingress_cnt[dst] += 1
+            dic[src].append(dst)
+
+        dq = deque([])            
+        for dst in range(numCourses):
+            if ingress_cnt[dst] == 0:
+                dq.append(dst)
+
+        visited_count = 0
+        while dq:
+            src = dq.popleft()
+            visited_count += 1
+
+            for dst in dic[src]:
+                ingress_cnt[dst] -= 1
+                if ingress_cnt[dst] == 0:
+                    dq.append(dst)
+        
+        return visited_count == numCourses
+    
+tc = [
+        (2, [[1,0]], True),
+        (2, [[1,0],[0,1]], False)
+]
+
+sol = Solution()
+for i, (n, p, e) in enumerate(tc, 1):
+    r = sol.canFinish(n, p)
+    print(f"TC {i} is Passed!" if r == e else f"TC {i} is Failed! - Expected: {e}, Result: {r}")