Merge branch 'main' of https://github.com/Tessa1217/leetcode-study

Author: Tessa1217

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

@@ -0,0 +1,42 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+
+    // 최대 Path 누적 합
+    int maxPathSumVal = Integer.MIN_VALUE;
+
+    // 시간복잡도: O(n), 공간복잡도: O(h) h as height of tree
+    public int maxPathSum(TreeNode root) {
+        maxPathSumChecker(root);
+        return maxPathSumVal;    
+    }
+
+    // 재귀
+    private int maxPathSumChecker(TreeNode node) {
+
+        if (node == null) {
+            return 0;
+        }
+
+        int leftMax = Math.max(maxPathSumChecker(node.left), 0);
+        int rightMax = Math.max(maxPathSumChecker(node.right), 0);
+
+        maxPathSumVal = Math.max(node.val + leftMax + rightMax, maxPathSumVal);
+
+        return node.val + Math.max(leftMax, rightMax);
+    }
+}
+

graph-valid-tree/Tessa1217.java

@@ -0,0 +1,57 @@
+public 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), 공간복잡도: O(n)
+    public boolean validTree(int n, int[][] edges) {
+      
+        if (edges.length != (n - 1)) {
+            return false; 
+        }
+
+        List<Integer>[] graph = new ArrayList[n];
+        for (int i = 0; i < n; i++) {
+            graph[i] = new ArrayList<>();
+        }
+
+        for (int[] edge : edges) {
+            graph[edge[0]].add(edge[1]);
+            graph[edge[1]].add(edge[0]);
+        }
+
+        boolean[] visited = new boolean[n];
+
+        if (!dfs(0, -1, visited, graph)) {
+            return false;
+        }
+
+        for (boolean v : visited) {
+            if (!v) {
+                return false; // Not fully connected
+            }
+        }
+
+        return true;
+    }
+
+    private boolean dfs(int node, int parent, boolean[] visited, List<Integer>[] graph) {
+        if (visited[node]) {
+            return false; // Found a cycle
+        }
+
+        visited[node] = true;
+
+        for (int neighbor : graph[node]) {
+            if (neighbor != parent) {
+                if (!dfs(neighbor, node, visited, graph)) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+}
+

merge-intervals/Tessa1217.java

@@ -0,0 +1,37 @@
+class Solution {
+    public int[][] merge(int[][] intervals) {
+
+        if (intervals.length <= 1) {
+            return intervals;
+        }
+
+        List<int[]> answer = new ArrayList<>();
+
+        Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
+        
+        int start = intervals[0][0];
+        int end = intervals[0][1];
+
+        for (int i = 1; i < intervals.length; i++) {
+
+            // 현재 인터벌 시작점
+            int currStart = intervals[i][0];
+            // 현재 인터벌 끝점 
+            int currEnd = intervals[i][1];
+
+            if (end >= currStart) {
+                end = Math.max(end, currEnd);                
+            } else {
+                answer.add(new int[]{start, end});
+                start = currStart;      
+                end = currEnd;
+            }            
+        }
+
+        answer.add(new int[]{start, end});
+
+        return answer.stream()
+                            .toArray(int[][]::new);
+    }
+}
+