From 0efebc08cb7c126692ad640fdd42ace1c1224362 Mon Sep 17 00:00:00 2001 From: hyerijung Date: Sun, 10 May 2026 14:13:25 +0900 Subject: [PATCH 1/5] missing numebr solutions --- missing-number/hyeri0903.java | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 missing-number/hyeri0903.java diff --git a/missing-number/hyeri0903.java b/missing-number/hyeri0903.java new file mode 100644 index 0000000000..14f7efa416 --- /dev/null +++ b/missing-number/hyeri0903.java @@ -0,0 +1,30 @@ +class Solution { + public int missingNumber(int[] nums) { + /** + 1.distinc number 로 이루어진 0~n 까지의 배열 중 missing number return + 2.constraints + - n 최소 = 1, 최대 = 10000 + - 배열길이 min=0, max=n + 3.solutions + - sorting 하고 for문으로 missing num check. time: O(n log n), space: O(1) + - 전체 sum - 실제 sum + */ + + Arrays.sort(nums); + int n = nums.length; + int answer = 0; + int i = 0; + + for(i = 0; i < n; i++) { + if(nums[i] != i) { + answer = i; + return answer; + } + } + if(i == n) { + answer = n; + return answer; + } + return answer; + } +} From 739c4308c4bfb8c6fa53ba147bd39b06445f0d43 Mon Sep 17 00:00:00 2001 From: hyerijung Date: Mon, 11 May 2026 15:44:12 +0900 Subject: [PATCH 2/5] merge intervlas solution --- merge-intervals/hyeri0903.java | 40 ++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 merge-intervals/hyeri0903.java diff --git a/merge-intervals/hyeri0903.java b/merge-intervals/hyeri0903.java new file mode 100644 index 0000000000..e14d30afad --- /dev/null +++ b/merge-intervals/hyeri0903.java @@ -0,0 +1,40 @@ +class Solution { + public int[][] merge(int[][] intervals) { + /** + 1.prob: overlapping 되는 곳을 merge 해서 return + 2.constraints + - len(intervalse) min = 1, max= 10000 + - start, end value min = 0, max = 10000 + 3.solution + - sorting array -> merge overlapping values + time: O(n log n) + */ + + int n = intervals.length; + Arrays.sort(intervals, (a,b) -> Integer.compare(a[0], b[0])); + + List answer = new ArrayList<>(); + int start = intervals[0][0]; + int end = intervals[0][1]; + + for(int i = 1; i < n; i++) { + int nextStart = intervals[i][0]; + int nextEnd = intervals[i][1]; + + //overlap + if(end >= nextStart) { + end = Math.max(end, nextEnd); + } else { + answer.add(new int[]{start, end}); + + start = nextStart; + end = nextEnd; + + } + } + + //last intervals + answer.add(new int[]{start, end}); + return answer.toArray(new int[answer.size()][]); + } +} From 86f9100cd3b2eaecf6ab7d7a9f67ce01e8ae1332 Mon Sep 17 00:00:00 2001 From: hyerijung Date: Sat, 16 May 2026 17:15:04 +0900 Subject: [PATCH 3/5] reorder-list solution --- reorder-list/hyeri0903.java | 61 +++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 reorder-list/hyeri0903.java diff --git a/reorder-list/hyeri0903.java b/reorder-list/hyeri0903.java new file mode 100644 index 0000000000..756da52a1c --- /dev/null +++ b/reorder-list/hyeri0903.java @@ -0,0 +1,61 @@ +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public void reorderList(ListNode head) { + /** + 1.Reorder linekd list from 0, n, 1, n-1, ... + 2.solution: + - 중간을 반으로 쪼개고,앞/뒤 리스트를 번갈아가면서 연결 + - step 1) 중간 노드 찾기 + - step 2) 뒤 리스트 reverse + - step 3) 두 리스트 merge + time: O(n), space: O(1) + */ + + ListNode slow = head; + ListNode fast = head; + + while(fast != null && fast.next != null) { + slow = slow.next; + fast = fast.next.next; + } + + ListNode second = slow.next; + slow.next = null; + + ListNode prev = null; + ListNode curr = second; + + //reverse second linked list + while(curr != null) { + ListNode next = curr.next; + curr.next = prev; + prev = curr; + curr = next; + } + + //merge two linked list + ListNode first = head; + LintNode secondHalf = prev; + + while(secondHalf != null) { + ListNode next1 = first.next; + ListNode next2 = secondHalf.next; + + next1.next = secondHalf + secondHalf.next = next1; + + first = next1; + secondHalf = next2; + } + + } +} From c966a4f953417b5a834f4769d6345abbf0cb7924 Mon Sep 17 00:00:00 2001 From: hyerijung Date: Sat, 16 May 2026 17:48:56 +0900 Subject: [PATCH 4/5] binary-tree-maximum-path-sum solution --- binary-tree-maximum-path-sum/hyeri0903.java | 48 +++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 binary-tree-maximum-path-sum/hyeri0903.java diff --git a/binary-tree-maximum-path-sum/hyeri0903.java b/binary-tree-maximum-path-sum/hyeri0903.java new file mode 100644 index 0000000000..89ccae88f2 --- /dev/null +++ b/binary-tree-maximum-path-sum/hyeri0903.java @@ -0,0 +1,48 @@ +/** + * 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 { + int maxValue = Integer.MIN_VALUE; + + public int maxPathSum(TreeNode root) { + /** + 1.노드의 sum이 가장 최대가 되는 path 의 maximum sum 찾기 + 2.solution : DFS + */ + + dfs(root); + return maxValue; + + } + + private int dfs(TreeNode node) { + if(node == null) { + return 0; + } + + int left = Math.max(0, dfs(node.left)); + int right = Math.max(0, dfs(node.right)); + + //현재 노드를 중심으로하는 Path + int currPath = left + node.val + right; + + //update max value + maxValue = Math.max(maxValue, currPath); + + //부모 노드에게 최대값 전달 + return node.val + Math.max(left, right); + } + +} From ac7518041afbb213ff32cf467ac1e9a681b1fdd5 Mon Sep 17 00:00:00 2001 From: hyerijung Date: Sat, 16 May 2026 18:17:20 +0900 Subject: [PATCH 5/5] graph-valid-tree solution --- graph-valid-tree/hyeri0903.java | 63 +++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 graph-valid-tree/hyeri0903.java diff --git a/graph-valid-tree/hyeri0903.java b/graph-valid-tree/hyeri0903.java new file mode 100644 index 0000000000..a2c659b551 --- /dev/null +++ b/graph-valid-tree/hyeri0903.java @@ -0,0 +1,63 @@ +public class Solution { + /** + * @param n: An integer + * @param edges: a list of undirected edges + * @return: true if it's a valid tree, or false + */ + public boolean validTree(int n, int[][] edges) { + /** + 1. n개의 노드 valid tree 검사 + 2. constraints + - no cycle + - all nodes are connected + 3. Solution: DFS + - 간선 개수 체크 + - 그래프 만들어서 cycle 없고 && 모두 방문했는지 체크 + 너모 어려워요... + */ + + //간선 개수 체크 + if(edges.length != n-1) { + return false; + } + + //그래프 만들기 + List> graph = new ArrayList<>(); + + for(int i = 0; i < n; i++) { + graph.add(new ArrayList<>()); + } + for(int[] edge: edges) { + int a = edge[0]; + int b = edge[1]; + graph.get(a).add(b); + graph.get(b).add(a); + } + //check through DFS + Set visited = new HashSet<>(); + + if(hasCycle(0, -1, graph, visited)) { + return false; + } + if(visited.size() != n) { + return false; + } + return true; + } + private boolean hasCycle(int node, int parent, List> graph, Set visited) { + //이미 방문했으면 cycle + if(visited.contains(node)) { + return true; + } + visited.add(node); + for(int neighbor: graph.get(node)) { + if(neighbor == parent) { + continue; + } + if(hasCycle(neighbor, node, graph, visited)) { + return true; + } + } + return false; + } +}