Merge branch 'DaleStudy:main' into main

Author: KwonNayeon

clone-graph/forest000014.java

@@ -70,7 +70,7 @@ public void dfs(Node oldNode) {
                 Node newNeighbor = createNode(oldNeighbor.val);
                 newNode.neighbors.add(newNeighbor);
                 newNeighbor.neighbors.add(newNode);
-                dfs(oldNeighbor, newNeighbor);
+                dfs(oldNeighbor);
             }
         }
     }

course-schedule/dusunax.py

@@ -0,0 +1,184 @@
+'''
+# 207
+참고 영상: https://www.youtube.com/watch?v=EgI5nU9etnU
+문제 풀이: https://www.algodale.com/problems/course-schedule/
+
+## 문제 정리
+👉 prerequisites란? 필수 선수 과목이다.  
+👉 방향성이 있는 연결 관계이므로, Directed Graph다.  
+👉 Cycle 발생 시, 코스를 이수할 수 없다.(서로 의존하는 순환이 있어서 끝없이 돌게 되는 경우)
+
+## 해결 방식 두가지
+1. BFS, Queue, Topological Sort: 위상 정렬
+2. DFS, Cycle Detection: 순환 탐지
+
+### 위상 정렬(Topological Sort) - BFS, Queue
+- 진입 차수(indegree): 노드로 들어오는 화살표 수
+- 그래프로 인접 리스트 구성
+- Queue에 넣기
+- Queue BFS 탐색
+- 모든 과목을 들었는지 확인
+
+### 순환 탐지(Cycle Detection) - DFS
+- 그래프로 인접 리스트 구성
+- 방문 상태 배열 초기화
+- dfs 함수
+- 모든 노드에 대해 dfs 실행
+
+## TC & SC
+- 시간 복잡도와 공간 복잡도는 O(V + E)로 동일하다.
+```
+V: 노드 수(과목 수)
+E: 간선 수(선수 과목 관계 수)
+```
+
+### TC is O(V + E)
+
+두 방법 모두, 그래프의 모든 노드와 간선을 한 번씩 확인함
+- BFS: 모든 V를 순회하면서, 각 노드에서 나가는 E를 따라가며 차수를 줄임
+- DFS: 모든 V를 순회하면서, 각 노드에서 연결된 E를 따라가며 깊이 탐색
+
+### SC is O(V + E)
+- O(V+E): V + E를 저장하는 인접 리스트 그래프
+- O(V)'s: 방문 상태 저장, 진입 차수 배열, BFS 큐, DFS 호출 스택
+
+## 위상정렬(BFS) vs 순환탐지(DFS)🤔
+
+### BFS를 사용했을 때
+- 반복문을 사용한 BFS가 indegree(진입차수) 개념이 보다 직관적이므로 => "순서대로 처리할 수 있는지 확인"할 때 명확하게 사용할 수 있다. 진입 차수가 0인 노드부터 시작해서 처리
+- 선수 과목을 다 들은 과목은 진입 차수가 0이 되므로 들어갈 수 있는 과목이라는 점이 명확함
+```
+키워드: 처리 순서를 출력, 순서대로 처리할 수 있는지
+```
+
+### DFS를 사용했을 때
+- DFS 순환 탐지는 "순환 여부"가 핵심일 때 자연스럽다.
+- 상태(Status)를 사용해서, 방문 중인 노드 상태를 다시 방문한다면 순환이 있음을 바로 알 수 있다.
+- 순환이 발견되면 바로 중단하므로, 순환 탐지에 자연스럽다.
+```
+키워드: 사이클이 있는지 판단
+```
+
+### +a) `@cache`를 활용해보자.
+- 파이선 3.9~ 메모이제이션 함수
+- 순수 함수 + 재귀 최적화에 사용 (외부 의존성, 부수효과에 주의할 것)
+'''
+from enum import Enum
+
+class Status(Enum): # use it to dfs
+    INITIAL = 1
+    IN_PROGRESS = 2
+    FINISHED = 3
+
+class Solution:
+    '''
+    1. BFS
+    위상 정렬
+    '''
+    def canFinishTopologicalSort(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        indegree = [0] * numCourses
+        graph = defaultdict(list)
+
+        for dest, src in prerequisites:
+            graph[src].append(dest)
+            indegree[dest] += 1
+
+        queue = deque([i for i in range(numCourses) if indegree[i] == 0])
+        processed_count = 0
+
+        while queue:
+            node = queue.popleft()
+            processed_count += 1
+            for neighbor in graph[node]:
+                indegree[neighbor] -= 1
+                if indegree[neighbor] == 0:
+                    queue.append(neighbor)
+        
+        return processed_count == numCourses
+
+    '''
+    2. DFS
+    순환 탐지
+    '''
+    def canFinishCycleDetection(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        graph = defaultdict(list)
+
+        for dest, src in prerequisites:
+            graph[src].append(dest)
+
+        statuses = {i: Status.INITIAL for i in range(numCourses)}
+
+        def dfs(node):
+            if statuses[node] == Status.IN_PROGRESS:
+                return False
+            if statuses[node] == Status.FINISHED:
+                return True
+
+            statuses[node] = Status.IN_PROGRESS
+            for neighbor in graph[node]:
+                if not dfs(neighbor):
+                    return False
+            statuses[node] = Status.FINISHED
+            return True
+
+        return all(dfs(crs) for crs in range(numCourses))
+
+    '''
+    3. @cache
+
+    파이썬 3.9 이상에서 사용하는 메모이제이션 데코레이터
+    - 동일 입력 -> 동일 출력을 보장한다.
+    - 128개 까지만 저장하는 @lru_cache도 있다.
+    '''
+    def canFinishWithCache(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        graph = defaultdict(list)
+
+        for dest, src in prerequisites:
+            graph[src].append(dest)
+
+        traversing = set()
+
+        @cache
+        def dfs(node):
+            if node in traversing:
+                return False
+
+            traversing.add(node)
+            result = all(dfs(pre) for pre in graph[node])
+            traversing.remove(node)
+            return result
+
+        return all(dfs(node) for node in range(numCourses))
+
+    '''
+    4. visited과 함께 사용하기
+
+    @cache 데코레이터는 메모이제이션, 같은 입력값에 따라 같은 결과를 반환하게함
+    결과가 변하지 않을 때 유용함 => dfs(node)는 외부 상태 순환 traversing에 의존해서 동작이 달라질 수 있다.
+    따라서 visited set이 더 자연스러울 수 있다
+    '''
+    def canFinishWithVisited(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        graph = defaultdict(list)
+
+        for dest, src in prerequisites:
+            graph[src].append(dest)
+
+        traversing = set() 
+        visited = set()    
+
+        def dfs(node):
+            if node in traversing:
+                return False
+            if node in visited:
+                return True
+
+            traversing.add(node)
+            for pre in graph[node]:
+                if not dfs(pre):
+                    return False
+            traversing.remove(node)
+
+            visited.add(node) 
+            return True
+
+        return all(dfs(i) for i in range(numCourses))

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/gwbaik9717.js

@@ -0,0 +1,68 @@
+// n: numCourses, p: len(prerequisites)
+// Time complexity: O(n + p)
+// Space complexity: O(n + p)
+
+class _Queue {
+  constructor() {
+    this.q = [];
+    this.start = 0;
+    this.end = 0;
+  }
+
+  isEmpty() {
+    return this.start === this.end;
+  }
+
+  push(value) {
+    this.q.push(value);
+    this.end++;
+  }
+
+  shift() {
+    const rv = this.q[this.start];
+    delete this.q[this.start++];
+
+    return rv;
+  }
+}
+
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {boolean}
+ */
+var canFinish = function (numCourses, prerequisites) {
+  const graph = Array.from({ length: numCourses }, () => []);
+  const inDegree = Array.from({ length: numCourses }, () => 0);
+
+  for (const [end, start] of prerequisites) {
+    graph[start].push(end);
+    inDegree[end]++;
+  }
+
+  const q = new _Queue();
+
+  for (let i = 0; i < numCourses; i++) {
+    if (inDegree[i] === 0) {
+      q.push(i);
+    }
+  }
+
+  let count = 0;
+
+  while (!q.isEmpty()) {
+    const current = q.shift();
+    count++;
+
+    // 현재 노드와 연결된 다른 노드의 차수 감소
+    for (const node of graph[current]) {
+      inDegree[node] -= 1;
+
+      if (inDegree[node] === 0) {
+        q.push(node);
+      }
+    }
+  }
+
+  return count === numCourses;
+};

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