Merge branch 'DaleStudy:main' into main

Author: gitsunmin

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

@@ -0,0 +1,24 @@
+// TC: O(n)
+// visit all nodes to find maximum path
+// SC: O(h)
+// h means the high of binary tree
+class Solution {
+    private int output = Integer.MIN_VALUE;
+    public int maxPathSum(TreeNode root) {
+        max(root);
+        return output;
+    }
+
+    private int max(TreeNode node) {
+        if (node == null) return 0;
+
+        int leftSum = Math.max(max(node.left), 0);
+        int rightSum = Math.max(max(node.right), 0);
+
+        int currentMax = node.val + leftSum + rightSum;
+
+        output = Math.max(output, currentMax);
+
+        return node.val + Math.max(leftSum, rightSum);
+    }
+}

binary-tree-maximum-path-sum/haklee.py

@@ -0,0 +1,62 @@
+"""TC: O(n), SC: O(h)
+
+
+아이디어:
+- 각 노드를 부모, 혹은 자식 노드의 관점에서 분석할 수 있다.
+- 부모 노드의 관점에서 경로를 만들때:
+    - 부모 노드는 양쪽 자식 노드에 연결된 경로를 잇는 다리 역할을 할 수 있다.
+    - 이때 자식 노드는
+        - 경로에 포함되지 않아도 된다. 이 경우 path에 0만큼 기여하는 것으로 볼 수 있다.
+        - 자식 노드의 두 자식 노드 중 한 쪽의 경로와 부모 노드를 이어주는 역할을 한다.
+          아래서 좀 더 자세히 설명.
+- 자식 노드의 관점에서 경로를 만들때:
+    - 자식 노드는 부모 노드와 연결될 수 있어야 한다.
+    - 그렇기 때문에 자신의 자식 노드 중 한 쪽과만 연결되어있을 수 있다. 만약 부모 노드와
+      본인의 양쪽 자식 노드 모두와 연결되어 있으면 이 노드가 세 갈림길이 되어서 경로를 만들
+      수 없기 때문.
+- 위의 분석을 통해 최대 경로를 만들고 싶다면, 다음의 함수를 root를 기준으로 재귀적으로 실행한다.
+    - 특정 node가 부모 노드가 되었다고 했을때 본인의 값에 두 자식의 max(최대 경로, 0) 값을 더해서
+      경로를 만들어본다. 이 값이 기존 solution보다 클 경우 solution을 업데이트.
+    - 특정 node가 자식 노드가 될 경우 본인의 두 자식 중 더 큰 경로를 부모에 제공해야 한다.
+      본인의 값에 max(왼쪽 경로, 오른쪽 경로)을 더해서 리턴.
+
+SC:
+- solution값을 관리한다. O(1).
+- 호출 스택은 트리의 높이만큼 쌓일 수 있다. O(h).
+- 종합하면 O(h).
+
+TC:
+- 각 노드에서 O(1) 시간이 소요되는 작업 수행.
+- 모든 노드에 접근하므로 O(n).
+"""
+
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def maxPathSum(self, root: Optional[TreeNode]) -> int:
+        sol = [-1001]  # 노드의 최소값보다 1 작은 값. 현 문제 세팅에서 -inf 역할을 함.
+
+        def try_get_best_path(node):
+            if node is None:
+                # 노드가 비어있을때 경로 없음. 이때 이 노드로부터 얻을 수 있는 최대 경로 값을
+                # 0으로 칠 수 있다.
+                return 0
+
+            # 왼쪽, 오른쪽 노드로부터 얻을 수 있는 최대 경로 값.
+            l = max(try_get_best_path(node.left), 0)
+            r = max(try_get_best_path(node.right), 0)
+
+            # 현 노드를 다리 삼아서 양쪽 자식 노드의 경로를 이었을때 나올 수 있는 경로 값이
+            # 최대 경로일 수도 있다. 이 값을 현 솔루션과 비교해서 업데이트 해준다.
+            sol[0] = max(node.val + l + r, sol[0])
+
+            # 현 노드의 부모 노드가 `이 노드를 통해 얻을 수 있는 최대 경로 값`으로 사용할 값을 리턴.
+            return node.val + max(l, r)
+
+        try_get_best_path(root)
+        return sol[0]

binary-tree-maximum-path-sum/jdalma.kt

@@ -0,0 +1,35 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+import kotlin.math.max
+
+class `binary-tree-maximum-path-sum` {
+
+    /**
+     * TC: O(n), SC: O(log n)
+     */
+    fun maxPathSum(root: TreeNode?): Int {
+        if (root == null) return 0
+        var max = root.`val`    // 부모 노드와 2개의 자식 노드의 합을 전역 변수로 갱신한다.
+
+        fun dfs(node: TreeNode?): Int {
+            if (node == null) return 0
+
+            val left = max(dfs(node.left), 0)
+            val right = max(dfs(node.right), 0)
+
+            max = max(node.`val` + left + right, max)
+            return node.`val` + max(left, right)    // 현재 노드와 2개의 자식 노드 중 최대의 값을 반환한다.
+        }
+
+        dfs(root)
+        return max
+    }
+
+    @Test
+    fun `이진 트리의 최대 경로 합을 반환한다`() {
+        maxPathSum(TreeNode.of(-10,9,20,null,null,15,7)) shouldBe 42
+        maxPathSum(TreeNode.of(1,9,20,null,null,15,7)) shouldBe 45
+    }
+}

graph-valid-tree/TonyKim9401.java

@@ -0,0 +1,37 @@
+// TC: O(n * m)
+// n = the length of edges, m = the length of each element list of edges
+// SC: O(n)
+// n = recursively visit everywhere
+public class Solution {
+    public boolean validTree(int n, int[][] edges) {
+        if (edges.length != n - 1) return false;
+
+        List<List<Integer>> graph = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            graph.add(new ArrayList<>());
+        }
+
+        for (int[] edge : edges) {
+            graph.get(edge[0]).add(edge[1]);
+            graph.get(edge[1]).add(edge[0]);
+        }
+
+        boolean[] visited = new boolean[n];
+        if (!dfs(0, -1, graph, visited)) return false;
+
+        for (boolean v : visited) if(!v) return false;
+
+        return true;
+    }
+
+    private boolean dfs(int node, int parent, List<List<Integer>> graph, boolean[] visited) {
+        visited[node] = true;
+
+        for (int neighbor : graph.get(node)) {
+            if (neighbor == parent) continue;
+            if (visited[neighbor]) return false;
+            if (!dfs(neighbor, node, graph, visited)) return false;
+        }
+        return true;
+    }
+}

graph-valid-tree/haklee.py

@@ -0,0 +1,160 @@
+"""
+아이디어:
+- 트리여야 하므로 엣지 개수가 n-1개여야 한다.
+- 엣지 개수가 n-1개이므로 만약 중간에 사이클이 있다면 트리가 연결이 안 된다.
+    - 연결이 안 되었으니 트리는 아니고... 몇 조각으로 쪼개진 그래프가 된다. 여튼, valid tree가
+      아니게 된다.
+    - spanning tree 만들 때를 생각해보자. 엣지 하나를 더할 때마다 노드가 하나씩 트리에 추가되어야
+      엣지 n-1개로 노드 n개를 겨우 만들 수 있는데, 중간에 새로운 노드를 추가 안하고 엄한 곳에
+      엣지를 써서 사이클을 만들거나 하면 모든 노드를 연결할 방법이 없다.
+    - 위의 예시보다 좀 더 일반적으로는 union-find 알고리즘에서 설명하는 union 시행으로도 설명이
+      가능하다. union-find에서는 처음에 n개의 노드들의 parent가 자기 자신으로 세팅되어 있는데,
+      즉, 모든 노드들이 n개의 그룹으로 나뉘어있는데, 여기서 union을 한 번 시행할 때마다 그룹이 1개
+      혹은 0개 줄어들 수 있다. 그런데 위 문제에서는 union을 엣지 개수 만큼, 즉, n-1회 시행할 수 있으므로,
+      만약 union 시행에서 그룹의 개수가 줄어들지 않는 경우(즉, 엣지 연결을 통해 사이클이 생길 경우)가
+      한 번이라도 발생하면 union 시행 후 그룹의 개수가 2 이상이 되어 노드들이 서로 연결되지 않아 트리를
+      이루지 못한다.
+"""
+
+"""TC: O(n * α(n)), SC: O(n)
+
+n은 주어진 노드의 개수, e는 주어진 엣지의 개수.
+
+아이디어(이어서):
+- union-find 아이디어를 그대로 활용한다.
+    - 나이브한 접근:
+        - union을 통해서 엣지로 연결된 두 집합을 합친다.
+        - find를 통해서 0번째 노드와 모든 노드들이 같은 집합에 속해있는지 확인한다.
+    - 더 좋은 구현:
+        - union 시행 중 같은 집합에 속한 두 노드를 합치려고 하는 것을 발견하면 False 리턴
+- union-find는 [Disjoint-set data structure - Wikipedia](https://en.wikipedia.org/wiki/Disjoint-set_data_structure)
+  를 기반으로 구현했다. 여기에 time complexity 관련 설명이 자세하게 나오는데 궁금하면 참고.
+
+SC:
+- union-find에서 쓸 parent 정보만 관리한다. 각 노드마다 parent 노드(인덱스), rank를 관리하므로 O(n).
+
+TC:
+- union 과정에 union by rank 적용시 O(α(n)) 만큼의 시간이 든다. 이때 α(n)은 inverse Ackermann function
+  으로, 매우 느린 속도로 늘어나므로 사실상 상수라고 봐도 무방하다.
+- union 시행을 최대 e번 진행하므로 O(e * α(n)).
+- e = n-1 이므로 O(n * α(n)).
+"""
+
+
+class Solution:
+    """
+    @param n: An integer
+    @param edges: a list of undirected edges
+    @return: true if it's a valid tree, or false
+    """
+
+    def valid_tree(self, n, edges):
+        # write your code here
+
+        # union find
+        parent = list(range(n))
+        rank = [0] * n
+
+        def find(x: int) -> bool:
+            if x == parent[x]:
+                return x
+
+            parent[x] = find(parent[x])  # path-compression
+            return parent[x]
+
+        def union(a: int, b: int) -> bool:
+            # 원래는 값을 리턴하지 않아도 되지만, 같은 집합에 속한 노드를
+            # union하려는 상황을 판별하기 위해 값 리턴.
+
+            pa = find(a)
+            pb = find(b)
+
+            # union by rank
+            if pa == pb:
+                # parent가 같음. rank 작업 안 해도 된다.
+                return True
+
+            if rank[pa] < rank[pb]:
+                pa, pb = pb, pa
+
+            parent[pb] = pa
+
+            if rank[pa] == rank[pb]:
+                rank[pa] += 1
+
+            return False
+
+        if len(edges) != n - 1:
+            # 트리에는 엣지가 `(노드 개수) - 1`개 만큼 있다.
+            # 이 조건 만족 안하면 커팅.
+            return False
+
+        # 나이브한 구현:
+        # - 모든 엣지로 union 시행
+        # - find로 모든 노드가 0번 노드와 같은 집합에 속해있는지 확인
+
+        # for e in edges:
+        #     union(*e)
+
+        # return all(find(0) == find(i) for i in range(n))
+
+        # 더 좋은 구현:
+        # - union 시행 중 같은 집합에 속한 두 노드를 합치려고 하는 것을 발견하면 False 리턴
+        for e in edges:
+            if union(*e):
+                return False
+
+        return True
+
+
+"""TC: O(n), SC: O(n)
+
+n은 주어진 노드의 개수, e는 주어진 엣지의 개수.
+
+아이디어(이어서):
+- 트리를 잘 이뤘는지 확인하려면 한 노드에서 시작해서 dfs를 돌려서 모든 노드들에 도달 가능한지
+  체크하면 되는데, 이게 시간복잡도에 더 유리하지 않을까?
+
+SC:
+- adjacency list를 관리한다. O(e).
+- 호출 스택은 탐색을 시작하는 노드로부터 사이클이 나오지 않는 경로의 최대 길이만큼 깊어질 수 있다.
+  최악의 경우 O(n).
+- 이때 e = n-1 이므로 종합하면 O(n).
+
+TC:
+- 각 노드에 접근하는 과정에 O(1). 이런 노드를 최악의 경우 n개 접근해야 하므로 O(n).
+"""
+
+
+class Solution:
+    """
+    @param n: An integer
+    @param edges: a list of undirected edges
+    @return: true if it's a valid tree, or false
+    """
+
+    def valid_tree(self, n, edges):
+        # write your code here
+        if len(edges) != n - 1:
+            # 트리에는 엣지가 `(노드 개수) - 1`개 만큼 있다.
+            # 이 조건 만족 안하면 커팅.
+            return False
+
+        adj_list = [[] for _ in range(n)]
+        for a, b in edges:
+            adj_list[a].append(b)
+            adj_list[b].append(a)
+
+        visited = [False for _ in range(n)]
+
+        def dfs(node):
+            visited[node] = True
+            for adj in adj_list[node]:
+                if not visited[adj]:
+                    dfs(adj)
+
+        # 한 노드에서 출발해서 모든 노드가 visted 되어야 주어진 엣지들로 트리를 만들 수 있다.
+        # 아무 노드에서나 출발해도 되는데 0번째 노드를 선택하자.
+        dfs(0)
+
+        return all(visited)

graph-valid-tree/jdalma.kt

@@ -0,0 +1,61 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+
+class `graph-valid-tree` {
+
+    /**
+     * TC: O(n), SC: O(n)
+     */
+    fun validTree(nodeSize: Int, edges: Array<IntArray>): Boolean {
+        if (nodeSize - 1 != edges.size) {
+            return false
+        }
+
+        val visited = mutableSetOf<Int>()
+        val adj = List(nodeSize) { mutableListOf<Int>() }
+        for (e in edges) {
+            adj[e[0]].add(e[1])
+            adj[e[1]].add(e[0])
+        }
+
+        val queue = ArrayDeque<Int>().apply {
+            this.add(0)
+        }
+
+        while (queue.isNotEmpty()) {
+            val now = queue.removeFirst()
+            visited.add(now)
+            for (next in adj[now]) {
+                if (!visited.contains(next)) {
+                    queue.add(next)
+                }
+            }
+        }
+
+        return nodeSize == visited.size
+    }
+
+    @Test
+    fun `노드가 트리의 조건을 만족하는지 여부를 반환한다`() {
+        validTree(5,
+            arrayOf(
+                intArrayOf(0,1),
+                intArrayOf(0,2),
+                intArrayOf(0,3),
+                intArrayOf(1,4)
+            )
+        ) shouldBe true
+
+        validTree(5,
+            arrayOf(
+                intArrayOf(0,1),
+                intArrayOf(0,2),
+                intArrayOf(0,3),
+                intArrayOf(1,4),
+                intArrayOf(2,3),
+            )
+        ) shouldBe false
+    }
+}