Merge branch 'DaleStudy:main' into main

Author: KwonNayeon

binary-tree-maximum-path-sum/HoonDongKang.ts

@@ -0,0 +1,38 @@
+/**
+ * [Problem]: [124 Binary Tree Maximum Path Sum
+ * (https://leetcode.com/problems/binary-tree-maximum-path-sum/description/)
+ */
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+//시간복잡도 O(n)
+//공간복잡도 O(h)
+function maxPathSum(root: TreeNode | null): number {
+    if (!root) return 0;
+    let result = root.val;
+
+    function dfs(node: TreeNode | null) {
+        if (!node) return 0;
+
+        let leftMax = Math.max(dfs(node.left), 0);
+        let rightMax = Math.max(dfs(node.right), 0);
+
+        result = Math.max(node.val + leftMax + rightMax, result);
+
+        return node.val + Math.max(leftMax, rightMax);
+    }
+
+    dfs(root);
+    return result;
+}

binary-tree-maximum-path-sum/minji-go.java

@@ -0,0 +1,26 @@
+/**
+ * <a href="https://leetcode.com/problems/binary-tree-maximum-path-sum/">week11-5. binary-tree-maximum-path-sum</a>
+ * <li>Description: Given the root of a binary tree, return the maximum path sum of any non-empty path</li>
+ * <li>Topics: Dynamic Programming, Tree, Depth-First Search, Binary Tree</li>
+ * <li>Time Complexity: O(N), Runtime 0ms   </li>
+ * <li>Space Complexity: O(H), Memory 44.1MB</li>
+ */
+class Solution {
+    public int maxPathSum(TreeNode root) {
+        dfs(root);
+        return max;
+    }
+
+    int max = Integer.MIN_VALUE;
+    public int dfs(TreeNode head) {
+        if (head == null) return 0;
+
+        int left = Math.max(0, dfs(head.left));
+        int right = Math.max(0, dfs(head.right));
+
+        max = Math.max(max, head.val + left + right);
+
+        return head.val + Math.max(left, right);
+    }
+
+}

binary-tree-maximum-path-sum/soobing.ts

@@ -0,0 +1,55 @@
+/**
+ * 문제 설명
+ * - 주어진 이진 트리에서 최대 경로 합을 구하는 문제
+ *
+ * 아이디어
+ * 1) 분할정복 + DFS
+ *   - DFS 아이디어: 각 노드를 루트로 하는 서브트리에서, 해당 노드를 포함한 최대 경로 합을 구해 전역 변수 maxSum을 업데이트한다.
+ *   - 현재 노드 기준의 최대 경로 합은: 현재 노드의 값 + 왼쪽 서브트리에서의 최대 경로 + 오른쪽 서브트리에서의 최대 경로.
+ *   - 하지만 dfs 함수의 반환값은 부모 노드에 연결될 수 있는 일방향 경로이므로,
+ *     '현재 노드의 값 + (왼쪽 또는 오른쪽 중 더 큰 값)'을 반환해야 한다.
+ */
+
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+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 maxPathSum(root: TreeNode | null): number {
+  let maxSum = -Infinity;
+
+  function dfs(node: TreeNode | null) {
+    if (!node) return 0;
+
+    const leftMaxSum = Math.max(dfs(node.left), 0);
+    const rightMaxSum = Math.max(dfs(node.right), 0);
+    const current = leftMaxSum + rightMaxSum + node.val;
+    maxSum = Math.max(current, maxSum);
+
+    return node.val + Math.max(leftMaxSum, rightMaxSum);
+  }
+
+  dfs(root);
+
+  return maxSum;
+}

binary-tree-maximum-path-sum/sora0319.java

@@ -0,0 +1,23 @@
+public class Solution {
+    private int maxSum;
+
+    public int maxPathSum(TreeNode root) {
+        maxSum = root.val;
+        dfs(root);
+        return maxSum;
+    }
+
+    private int dfs(TreeNode node) {
+        if (node == null) {
+            return 0;
+        }
+
+        int leftMax = Math.max(dfs(node.left), 0);
+        int rightMax = Math.max(dfs(node.right), 0);
+
+        maxSum = Math.max(maxSum, node.val + leftMax + rightMax);
+
+        return node.val + Math.max(leftMax, rightMax);
+    }
+}
+

course-schedule/minji-go.java

@@ -0,0 +1,45 @@
+/**
+ * <a href="https://leetcode.com/problems/course-schedule/">week10-3. course-schedule   </a>
+ * <li>Description: Return true if you can finish all courses. Otherwise, return false  </li>
+ * <li>Topics: Depth-First Search, Breadth-First Search, Graph, Topological Sort        </li>
+ * <li>Time Complexity: O(N+E), Runtime 7ms        </li>
+ * <li>Space Complexity: O(N+E), Memory 45.68MB    </li>
+ * <li>Note : refer to the answer. remember the topic of topological sort </li>
+ */
+class Solution {
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        int[] inDegree = new int[numCourses];
+        List<List<Integer>> graph = new ArrayList<>();
+        for (int i=0; i<numCourses; i++){
+            graph.add(new ArrayList<>());
+        }
+
+        for(int[] pre : prerequisites) {
+            int dest = pre[0], src = pre[1];
+            graph.get(src).add(dest);
+            inDegree[dest]++;
+        }
+
+        Queue<Integer> queue = new LinkedList<>();
+        for (int i=0; i<numCourses; i++) {
+            if(inDegree[i] == 0) {
+                queue.offer(i);
+            }
+        }
+
+        int count = 0;
+        while(!queue.isEmpty()){
+            int node = queue.poll();
+            count++;
+
+            for(int neighbor : graph.get(node)) {
+                inDegree[neighbor]--;
+                if(inDegree[neighbor] == 0) {
+                    queue.offer(neighbor);
+                }
+            }
+        }
+
+        return count == numCourses;
+    }
+}

graph-valid-tree/HoonDongKang.ts

@@ -0,0 +1,65 @@
+/**
+ * [Problem]: [178] Graph Valid Tree
+ * (https://www.lintcode.com/problem/178/)
+ */
+
+export class Solution {
+    /**
+     * @param n: An integer
+     * @param edges: a list of undirected edges
+     * @return: true if it's a valid tree, or false
+     */
+    //시간복잡도 O(n+e)
+    //공간복잡도 O(n+e)
+    validTree(n: number, edges: number[][]): boolean {
+        const graph: number[][] = Array.from({ length: n }, () => []);
+        for (const [a, b] of edges) {
+            graph[a].push(b);
+            graph[b].push(a);
+        }
+
+        const visited = new Set<number>();
+
+        function hasCycle(node: number, prev: number): boolean {
+            if (visited.has(node)) return true;
+            visited.add(node);
+
+            for (const neighbor of graph[node]) {
+                if (neighbor === prev) continue;
+                if (hasCycle(neighbor, node)) return true;
+            }
+            return false;
+        }
+
+        if (hasCycle(0, -1)) return false;
+
+        return visited.size === n;
+    }
+
+    //시간복잡도 O(n)
+    //공간복잡도 O(n)
+    validTree2(n: number, edges: number[][]): boolean {
+        if (edges.length !== n - 1) return false;
+
+        const graph: number[][] = Array.from({ length: n }, () => []);
+        for (const [a, b] of edges) {
+            graph[a].push(b);
+            graph[b].push(a);
+        }
+
+        const visited = new Set<number>();
+
+        function dfs(node: number) {
+            visited.add(node);
+            for (const neighbor of graph[node]) {
+                if (!visited.has(neighbor)) {
+                    dfs(neighbor);
+                }
+            }
+        }
+
+        dfs(0);
+
+        return visited.size === n;
+    }
+}

graph-valid-tree/hi-rachel.py

@@ -0,0 +1,42 @@
+"""
+- 정점 개수 n, 간선 배열 edges
+- 무방향 그래프
+
+트리 조건
+1. 완전히 연결된 그래프여야 함 -> 전체 탐색 가능
+2. 그래프에 순환하는 부분이 없어야 함
+
+트리 특성상 항상 e = n - 1, 즉 간선의 수 = 노드의 개수 - 1
+
+TC: O(n)
+SC: O(n)
+"""
+
+from typing import List
+
+class Solution:
+    def validTree(self, n: int, edges: List[List[int]]) -> bool:
+        graph = [[] for _ in range(n)]
+        visited = set()
+
+        for a, b in edges:
+            graph[a].append(b)
+            graph[b].append(a)
+
+        def has_cycle(node, prev):
+            # 이미 방문 = 순환 -> 트리 x
+            if node in visited:
+                return True
+            visited.add(node)
+            for adj in graph[node]:
+                if adj == prev:
+                    continue
+                if has_cycle(adj, node):
+                    return True
+
+            return False
+        
+        if has_cycle(0, -1):
+            return False
+
+        return len(visited) == n

graph-valid-tree/soobing.js

@@ -0,0 +1,41 @@
+/**
+ * 문제 설명
+ * - 주어진 간선 정보로 트리가 만들어지는지 확인하는 문제
+ * - 어려웠음 다시 풀어보기 ⚠️
+ * 
+ * 트리의 조건
+ * 1) 모든 노드가 연결되어 있어야 한다.
+ * 2) 사이클이 없어야 한다.
+ * 3) 총 간선의 갯수는 n-1개여야 한다.
+ * 
+ * 아이디어
+ * 1) Union-Find (Disjoint Set)
+ * 2) DFS ✅
+ */
+function validTree(n, edges) {
+  if (edges.length !== n - 1) return false; // 간선 수가 n - 1이 아니면 트리 불가
+
+  const graph = Array.from({ length: n }, () => []);
+  for (const [a, b] of edges) {
+    graph[a].push(b);
+    graph[b].push(a);
+  }
+
+  const visited = new Set();
+
+  const dfs = (node, prev) => {
+    if (visited.has(node)) return false;
+    visited.add(node);
+
+    for (const neighbor of graph[node]) {
+      if (neighbor === prev) continue; // 바로 이전 노드는 무시, 체크하는 이유: 무방향 그래프이기 때문에 사이클로 들어가게 하지 않기 위함.
+      if (!dfs(neighbor, node)) return false; // 사이클 발생
+    }
+
+    return true;
+  };
+
+  if (!dfs(0, -1)) return false;
+
+  return visited.size === n;
+}

graph-valid-tree/sora0319.java

@@ -0,0 +1,40 @@
+public class Solution {
+    public boolean validTree(int n, int[][] edges) {
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            graph.put(i, new ArrayList<>());
+        }
+
+        for (int[] edge : edges) {
+            int node = edge[0];
+            int adj = edge[1];
+            graph.get(node).add(adj);
+            graph.get(adj).add(node);
+        }
+
+        Set<Integer> visited = new HashSet<>();
+        if (inCycle(0, -1, graph, visited)) {
+            return false;
+        }
+
+        return visited.size() == n;
+    }
+
+    private boolean inCycle(int node, int prev, Map<Integer, List<Integer>> graph, Set<Integer> visited) {
+        if (visited.contains(node)) {
+            return true;
+        }
+
+        visited.add(node);
+
+        for (int neighbor : graph.get(node)) {
+            if (neighbor == prev) continue;
+            if (inCycle(neighbor, node, graph, visited)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
+