Merge branch 'DaleStudy:main' into main

Author: mike2ox

3sum/forest000014.java

@@ -0,0 +1,63 @@
+/*
+# Time Complexity: O(n^2)
+# Space Complexity: O(1)
+*/
+
+class Solution {
+    public List<List<Integer>> threeSum1(int[] nums) { // solution 1
+        int n = nums.length;
+        Arrays.sort(nums);
+        Set<List<Integer>> ans = new HashSet<>();
+
+        for (int i = 0; i < n - 2; i++) {
+            for (int j = i + 1; j < n - 1; j++) {
+                int target = -nums[i] - nums[j]; // nums[i], nums[j]와 더해서 합이 0이 되기 위해 nums[k]가 가져야하는 값
+                int k = -1;
+                int l = j + 1;
+                int r = n - 1;
+                while (l <= r) {
+                    int m = (r - l) / 2 + l;
+                    if (nums[m] == target) {
+                        k = m;
+                        break;
+                    } else if (nums[m] < target) {
+                        l = m + 1;
+                    } else {
+                        r = m - 1;
+                    }
+                }
+                if (k != -1) { // binary search에서 target을 찾은 경우
+                    ans.add(new ArrayList<>(Arrays.asList(nums[i], nums[j], nums[k])));
+                }
+            }
+        }
+
+        return new ArrayList<>(ans);
+    }
+
+    public List<List<Integer>> threeSum(int[] nums) { // solution 2
+        int n = nums.length;
+        Arrays.sort(nums);
+        Set<List<Integer>> ans = new HashSet<>();
+
+        for (int i = 0; i < n - 2; i++) {
+            int l = i + 1;
+            int r = n - 1;
+            int target = -nums[i];
+            while (l < r) {
+                int sum = nums[l] + nums[r];
+                if (sum == target) {
+                    ans.add(new ArrayList<>(Arrays.asList(nums[i], nums[l], nums[r])));
+                    l++;
+                    r--; // 또 다른 (l, r) 조합이 있을 수 있으므로, loop를 계속 이어간다.
+                } else if (sum < target) {
+                    l++;
+                } else {
+                    r--;
+                }
+            }
+        }
+
+        return new ArrayList<>(ans);
+    }
+}

binary-tree-level-order-traversal/imsosleepy.java

@@ -0,0 +1,27 @@
+// dfs와 분할 정복법으로 해결되는 문제
+// dfs인 것을 알았으나 모든 숫자가 음수일 경우를 판별하지 못해 GPT에게 도움을 처함
+class Solution {
+    private int maxSum = Integer.MIN_VALUE; // 전체 최대 경로 합 저장
+
+    public int maxPathSum(TreeNode root) {
+        dfs(root);
+        return maxSum;
+    }
+
+    private int dfs(TreeNode node) {
+        if (node == null) return 0; // base case
+
+        // 왼쪽, 오른쪽 서브트리의 최대 경로 합 (음수는 포함 X → Math.max(0, value))
+        int left = Math.max(0, dfs(node.left));
+        int right = Math.max(0, dfs(node.right));
+
+        // 현재 노드를 포함한 최대 경로 (왼쪽 + 루트 + 오른쪽)
+        int pathSum = left + node.val + right;
+
+        // 최대 경로 값 갱신
+        maxSum = Math.max(maxSum, pathSum);
+
+        // ✅ 현재 노드를 포함하는 최대 경로 값만 반환해야 함 (연결 가능한 경로)
+        return node.val + Math.max(left, right);
+    }
+}