Merge branch 'DaleStudy:main' into main

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

@@ -0,0 +1,39 @@
+# 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
+
+"""
+Solution: DFS
+    1) dfs 로 left, right 각각의 max 값을 구한다.
+    2) maxSum 을 업데이트하고, 
+    3) return value 로는 leftMax 또는 rightMax 와의 합만 리턴한다. 
+    (left, right 를 둘 다 포함하는 경우와 둘 중 하나만 선택하는 경우를 나눔)
+
+Time: O(n)
+Space: O(n)
+
+"""
+
+
+class Solution:
+    def maxPathSum(self, root: Optional[TreeNode]) -> int:
+        maxSum = root.val
+
+        def dfs(root):
+            nonlocal maxSum
+            if not root:
+                return 0
+
+            leftMax = dfs(root.left)
+            rightMax = dfs(root.right)
+            leftMax = max(leftMax, 0)
+            rightMax = max(rightMax, 0)
+
+            maxSum = max(maxSum, root.val + leftMax + rightMax)
+            return root.val + max(leftMax, rightMax)
+
+        dfs(root)
+        return maxSum

binary-tree-maximum-path-sum/gwbaik9717.js

@@ -0,0 +1,47 @@
+// Time complexity: O(n)
+// Space complexity: O(n)
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var maxPathSum = function (root) {
+  let answer = Number.MIN_SAFE_INTEGER;
+
+  const dfs = (current) => {
+    const candidates = [current.val];
+
+    if (current.left) {
+      dfs(current.left);
+      candidates.push(current.left.val + current.val);
+    }
+
+    if (current.right) {
+      dfs(current.right);
+      candidates.push(current.right.val + current.val);
+    }
+
+    // 현재 노드가 루트일 경우
+    if (current.left && current.right) {
+      answer = Math.max(
+        answer,
+        current.left.val + current.right.val + current.val
+      );
+    }
+
+    current.val = Math.max(...candidates);
+    answer = Math.max(answer, current.val);
+  };
+
+  dfs(root);
+
+  return answer;
+};

graph-valid-tree/Chaedie.py

@@ -0,0 +1,39 @@
+"""
+Conditions of Valid Tree
+1) no Loop
+2) all nodes has to be connected
+
+Time: O(node + edge)
+Space: O(node + edge)
+"""
+
+
+class Solution:
+    def validTree(self, n: int, edges: List[List[int]]) -> bool:
+        if not n:
+            return True
+        if len(edges) != n - 1:
+            return False
+
+        # Make Graph
+        graph = {i: [] for i in range(n)}
+        for n1, n2 in edges:
+            graph[n1].append(n2)
+            graph[n2].append(n1)
+
+        # loop check
+        visit = set()
+
+        def dfs(i, prev):
+            if i in visit:
+                return False
+
+            visit.add(i)
+            for j in graph[i]:
+                if j == prev:
+                    continue
+                if not dfs(j, i):
+                    return False
+            return True
+
+        return dfs(0, None) and n == len(visit)

graph-valid-tree/KwonNayeon.py

@@ -0,0 +1,46 @@
+"""
+Valid Tree의 조건:
+1. 모든 노드가 연결되어 있어야 함
+2. 사이클이 없어야 함 
+3. edge의 개수는 n-1개
+
+Time Complexity: O(V + E)  
+- V: 노드의 개수
+- E: edge의 개수
+
+Space Complexity: O(V)
+- 노드 방문 여부를 저장하는 visited set 사용
+
+풀이방법:
+1. 기본 조건 체크: edge의 개수는 n-1개
+2. 각 노드별로 연결된 노드들의 정보를 저장
+   - 무방향 그래프이므로 양쪽 모두 저장
+3. DFS로 노드 탐색
+   - 0번 노드부터 시작해서 연결된 모든 노드를 방문
+   - 이미 방문한 노드는 재방문하지 않음
+4. 모든 노드 방문 확인
+   - visited의 크기가 n과 같다면 모든 노드가 연결된 것 -> valid tree
+"""
+def validTree(n, edges):
+    if len(edges) != n - 1:
+        return False
+
+    adj = [[] for _ in range(n)]
+    for a, b in edges:
+        adj[a].append(b)
+        adj[b].append(a)
+
+    visited = set()
+
+    def dfs(node):
+        if node in visited:
+            return
+
+        visited.add(node)
+
+        for next_node in adj[node]:
+            dfs(next_node)
+
+    dfs(0)
+    return len(visited) == n
+

graph-valid-tree/dusunax.py

@@ -0,0 +1,67 @@
+'''
+# 261. Graph Valid Tree
+
+## What constitutes a 🌲
+1. it's a graph.
+2. Connected: edges == n - 1, visited node count == n
+3. Acyclic: there is no cycle.
+
+## Approach A. DFS
+use DFS to check if there is a cycle in the graph.
+- if there were no cycle & visited node count == n, return True.
+
+## Approach B. Disjoint Set Union (서로소 집합)
+use Disjoint Set Union to check if there is a cycle in the graph.
+- if you find a cycle, return False immediately.
+- if you find no cycle, return True.
+
+### Union Find Operation
+- Find: find the root of a node.
+  - if the root of two nodes is already the same, there is a cycle.
+- Union: connect two nodes. 
+
+## Approach Comparison
+- **A. DFS**: simple and easy to understand.
+- **B. Disjoint Set Union**: quicker to check if there is a cycle. if there were more edges, Union Find would be faster.
+'''
+class Solution:
+    def validTreeDFS(self, n: int, edges: List[List[int]]) -> bool:
+        if len(edges) != n - 1:
+            return False
+
+        graph = [[] for _ in range(n)]
+        for node, neighbor in edges:
+            graph[node].append(neighbor)
+            graph[neighbor].append(node)
+
+        visited = set()
+        def dfs(node):
+            visited.add(node)
+            for neighbor in graph[node]:
+                if neighbor not in visited:
+                    dfs(neighbor)
+
+        dfs(0)
+        return len(visited) == n
+
+    def validTreeUnionFind(self, n: int, edges: List[List[int]]) -> bool:
+        if len(edges) != n - 1:
+            return False
+
+        parent = [i for i in range(n)]
+
+        def find(x):
+            if x == parent[x]:
+                return x
+            parent[x] = find(parent[x])
+            return parent[x]
+
+        def union(x, y):
+            parent[find(x)] = find(y)
+
+        for node, neighbor in edges:
+            if find(node) == find(neighbor):
+                return False
+            union(node, neighbor)
+
+        return True

graph-valid-tree/mike2ox.ts

@@ -0,0 +1,45 @@
+/**
+ * Source: https://www.lintcode.com/problem/178/
+ * Solution: 유효한 트리인지 순회하면서 확인하면 되기에 BFS로 구현
+ * 시간 복잡도: O(V + E) - 노드와 간선에 한번은 방문
+ * 공간 복잡도: O(V + E) - 인접리스트 만큼의 공간 필요
+ */
+function validTree(n: number, edges: number[][]): boolean {
+  // 간선 개수 체크: 트리는 노드 개수 - 1개의 간선을 가져야 함
+  if (edges.length !== n - 1) return false;
+
+  // 인접 리스트
+  const adjList: Map<number, number[]> = new Map();
+  for (let i = 0; i < n; i++) {
+    adjList.set(i, []);
+  }
+
+  // 양방향 그래프 구성
+  for (const [u, v] of edges) {
+    adjList.get(u)!.push(v);
+    adjList.get(v)!.push(u);
+  }
+
+  const queue: [number, number][] = [[0, -1]]; // [노드, 부모노드]
+  const visited: Set<number> = new Set([0]);
+
+  while (queue.length > 0) {
+    const [node, parent] = queue.shift()!;
+
+    // 모든 이웃 노드 확인
+    for (const neighbor of adjList.get(node)!) {
+      // 부모 노드는 continue
+      if (neighbor === parent) continue;
+
+      // 이미 방문한 노드를 만나면 사이클 존재
+      if (visited.has(neighbor)) return false;
+
+      // 이웃 노드를 큐에 추가하고 방문 표시
+      visited.add(neighbor);
+      queue.push([neighbor, node]);
+    }
+  }
+
+  // 모든 노드가 연결되어 있는지 확인
+  return visited.size === n;
+}

maximum-depth-of-binary-tree/Chaedie.py

@@ -0,0 +1,23 @@
+"""
+Solution: BFS 
+Time: O(n)
+Space: O(n)
+"""
+
+
+class Solution:
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        if not root:
+            return 0
+
+        q = deque([root])
+        maxLevel = 0
+        while q:
+            maxLevel += 1
+            for i in range(len(q)):
+                node = q.popleft()
+                if node.left:
+                    q.append(node.left)
+                if node.right:
+                    q.append(node.right)
+        return maxLevel

maximum-depth-of-binary-tree/KwonNayeon.py

@@ -0,0 +1,56 @@
+"""
+Constraints:
+- The number of nodes in the tree is in the range [0, 10^4].
+- -100 <= Node.val <= 100
+
+Time Complexity: O(N)
+- N은 트리의 노드 수
+- 모든 노드를 한 번씩 방문하기 때문
+
+Space Complexity: O(H)
+- H는 트리의 높이
+- 재귀 호출로 인한 호출 스택의 최대 깊이가 트리의 높이와 같음
+
+풀이방법:
+1. Base case: root가 None인 경우 0을 반환
+2. 재귀를 활용하여 왼쪽과 오른쪽 서브트리 깊이를 각각 계산
+3. 두 서브트리의 깊이 중 최대값에 1을 더해서 반환 (현재 노드의 깊이를 포함)
+"""
+# 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
+
+# Solution 1: 재귀
+class Solution:
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        if root is None:
+            return 0
+
+        left_depth = self.maxDepth(root.left)
+        right_depth = self.maxDepth(root.right)
+
+        return max(left_depth, right_depth) + 1
+
+# Solution 2: 반복문
+class Solution:
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        if root is None:
+            return 0
+
+        stack = [(root, 1)]
+        max_depth = 0
+
+        while stack:
+            current, depth = stack.pop()
+
+            max_depth = max(max_depth, depth)
+
+            if current.left:
+                stack.append((current.left, depth + 1))
+            if current.right:
+                stack.append((current.right, depth + 1))
+
+        return max_depth