Merge branch 'DaleStudy:main' into main

Author: Sunjae95

binary-tree-maximum-path-sum/HC-kang.ts

@@ -0,0 +1,65 @@
+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;
+  }
+}
+
+/**
+ * https://leetcode.com/problems/binary-tree-maximum-path-sum
+ * T.C. O(n)
+ * S.C. O(n)
+ */
+function maxPathSum(root: TreeNode | null): number {
+  let max = -Infinity;
+
+  function dfs(node: TreeNode | null): number {
+    if (!node) return 0;
+
+    const left = Math.max(0, dfs(node.left));
+    const right = Math.max(0, dfs(node.right));
+
+    max = Math.max(max, node.val + left + right);
+
+    return node.val + Math.max(left, right);
+  }
+
+  dfs(root);
+
+  return max;
+}
+
+/**
+ * iterative using stack
+ * T.C. O(n)
+ * S.C. O(n)
+ */
+function maxPathSum(root: TreeNode | null): number {
+  let max = -Infinity;
+  const stack: Array<TreeNode | null> = [root];
+  const memo = new Map<TreeNode, number>();
+
+  while (stack.length) {
+    const node = stack.pop();
+
+    if (!node) continue;
+
+    if (memo.has(node)) {
+      const left = Math.max(0, node.left ? memo.get(node.left)! : 0);
+      const right = Math.max(0, node.right ? memo.get(node.right)! : 0);
+
+      max = Math.max(max, node.val + left + right);
+
+      memo.set(node, node.val + Math.max(left, right));
+    } else {
+      stack.push(node, node.right, node.left);
+      memo.set(node, 0);
+    }
+  }
+
+  return max;
+}

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/flynn.go

@@ -0,0 +1,61 @@
+/*
+풀이
+- post order traversal dfs를 활용하여 풀이할 수 있습니다
+Big O
+- N: node의 개수
+- H: Tree의 높이
+- Time compleixty: O(N)
+  - 모든 node를 최대 한 번 탐색합니다
+- Space complexity: O(H)
+  - 재귀 호출 스택의 깊이는 H에 비례하여 증가합니다
+*/
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+ func maxPathSum(root *TreeNode) int {
+	res := root.Val
+
+	var maxSubtreeSum func(*TreeNode) int
+	maxSubtreeSum = func(node *TreeNode) int {
+		// base case
+		if node == nil {
+			return 0
+		}
+		// left subtree로 내려갔을 때 구할 수 있는 maximum path sum
+		// left subtree로 path를 내려갔을 때, left subtree가 sum에 기여하는 값이 0보다 작을 경우
+		// left subtree로는 path를 내려가지 않는 것이 좋음
+		// 따라서 left < 0 인 경우엔 left = 0
+		left := maxSubtreeSum(node.Left)
+		if left < 0 {
+			left = 0
+		}
+		// right subtree도 left subtree와 동일함
+		right := maxSubtreeSum(node.Right)
+		if right < 0 {
+			right = 0
+		}
+		// 현재 탐색하고 있는 node의 조상 node를 path에 포함하지 않고도
+		// maxPathSum이 구해지는 경우가 있음
+		if res < left+right+node.Val {
+			res = left + right + node.Val
+		}
+		// 현재까지 계산한 subtree path sum을 부모 node에게 전달해야 함
+		// 현재 node의 부모와 이어지는 path여야 하므로, node.Val + max(left, right)를 반환하면 됨
+		subTreeSum := node.Val
+		if left > right {
+			subTreeSum += left
+		} else {
+			subTreeSum += right
+		}
+		return subTreeSum
+	}
+
+	maxSubtreeSum(root)
+	return res
+}

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]

graph-valid-tree/HC-kang.ts

@@ -0,0 +1,33 @@
+/**
+ * https://leetcode.com/problems/graph-valid-tree
+ * T.C. O(n)
+ * S.C. O(n)
+ */
+function validTree(n: number, edges: number[][]): boolean {
+  if (edges.length !== n - 1) return false;
+
+  const parent = Array.from({ length: n }, (_, i) => i);
+
+  // find and compress path
+  function find(x: number): number {
+    if (parent[x] !== x) {
+      parent[x] = find(parent[x]);
+    }
+    return parent[x];
+  }
+
+  // union two sets and check if they have the same root
+  function union(x: number, y: number): boolean {
+    const rootX = find(x);
+    const rootY = find(y);
+    if (rootX === rootY) return false;
+    parent[rootX] = rootY;
+    return true;
+  }
+
+  for (const [x, y] of edges) {
+    if (!union(x, y)) return false;
+  }
+
+  return true;
+}

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/flynn.go

@@ -0,0 +1,57 @@
+/*
+풀이
+- valid tree인지 판별하는 문제입니다
+  주어진 input이 valid tree이려면,
+  1. cycle이 없어야 합니다 (cycle이 있는 경우: [[0, 1], [1, 2], [2, 0]])
+  2. 모든 node가 연결되어 있어야 합니다 (모든 node가 연결되지 않은 경우: [[0, 1], [2, 3]])
+- dfs 방식의 함수를 재귀 호출하여 풀이할 수 있습니다
+Big O
+- N: n
+- E: 주어진 배열 edges의 크기
+- Time complexity: O(N)
+  - 모든 node를 최대 1번씩 탐색합니다
+- Space complexity: O(E + N)
+  - visited의 크기는 N에 비례하여 증가합니다 -> O(N)
+  - adj의 크기는 E에 비례하여 증가합니다 -> O(E)
+  - dfs의 재귀호출 스택 깊이는 최악의 경우 N까지 커질 수 있습니다 -> O(N)
+*/
+
+func validTree(n int, edges [][]int) bool {
+	// valid tree는 n-1개의 edge를 가질 수 밖에 없습validTree
+	// 아래 판별식을 이용하면 유효하지 않은 input에 대해 상당한 연산을 줄일 수 있습니다
+	if len(edges) != n-1 {
+		return false
+	}
+	// 주어진 2차원 배열 edges를 이용해 adjacency list를 생성합니다
+	adj := make([][]int, n)
+	for _, edge := range edges {
+		adj[edge[0]] = append(adj[edge[0]], edge[1])
+		adj[edge[1]] = append(adj[edge[1]], edge[0])
+	}
+	// cycle이 있는지 여부를 판단하기 위해 visited라는 map을 생성합니다 (Go에서는 map으로 set 기능을 대신함)
+	visited := make(map[int]bool)
+
+	var dfs func(int, int) bool
+	dfs = func(node int, parent int) bool {
+		// cycle 발견시 false return
+		if _, ok := visited[node]; ok {
+			return false
+		}
+		visited[node] = true
+		for _, next := range adj[node] {
+			if next == parent {
+				continue
+			}
+			if !dfs(next, node) {
+				return false
+			}
+		}
+		return true
+	}
+	// cycle 여부를 판단합니다
+	if !dfs(0, -1) {
+		return false
+	}
+	// node가 모두 연결되어 있는지 여부를 판단합니다
+	return len(visited) == n
+}