[최원준]Day13

leetcode2/1easy/최원준/Q94.java

@@ -0,0 +1,45 @@
+package Leetcode.최원준;
+
+/*
+1. 아이디어 :
+inorder traversal = left -> root -> right
+
+2. 시간복잡도 :
+O( n )
+
+3. 자료구조/알고리즘 :
+- / -
+ */
+
+public class Q94 {
+/*
+ * 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 {
+    List<Integer> ans = new ArrayList<>();
+    public void inorder(TreeNode node) {
+        if (node == null) return;
+
+        inorder(node.left);
+        ans.add(node.val);
+        inorder(node.right);
+    }
+    public List<Integer> inorderTraversal(TreeNode root) {
+        inorder(root);
+        return ans;
+    }
+}
+ */
+}

leetcode2/2medium/최원준/Q15.java

@@ -0,0 +1,51 @@
+package Leetcode.최원준;
+
+/*
+1. 아이디어 :
+정렬 후, 왼쪽, 중간, 오른쪽 포인터를 둔다.
+왼쪽은 0부터 순회하고,
+중간, 오른쪽은 이분탐색을 수행한다.
+포인터를 옮기게 되면, 중복된 숫자는 건너뛴다.
+
+2. 시간복잡도 :
+O( nlogn )
+
+3. 자료구조/알고리즘 :
+- / 이분탐새
+ */
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Q15 {
+    class Solution {
+        public List<List<Integer>> threeSum(int[] nums) {
+            int n = nums.length;
+            Arrays.sort(nums);
+            List<List<Integer>> ans = new ArrayList<>();
+            for (int left = 0; left<n; left++) {
+                int lv = nums[left];
+                int mid = left+1, right = n-1;
+                while (mid < right) {
+                    int mv = nums[mid], rv = nums[right];
+                    if (lv + mv + rv == 0) {
+                        ans.add(List.of(lv, mv, rv));
+                        while (mid+1 < n && nums[mid] == nums[mid+1]) mid++;
+                        while (right-1 >= 0 && nums[right] == nums[right-1]) right--;
+                        mid++;
+                        right--;
+                    } else if (lv+mv+rv < 0) {
+                        while (mid+1 < n && nums[mid] == nums[mid+1]) mid++;
+                        mid++;
+                    } else if (lv+mv+rv > 0) {
+                        while (right-1 >= 0 && nums[right] == nums[right-1]) right--;
+                        right--;
+                    }
+                }
+                while (left+1 < n && nums[left] == nums[left+1]) left++;
+            }
+            return ans;
+        }
+    }
+}

leetcode2/2medium/최원준/Q200.java

@@ -0,0 +1,54 @@
+package Leetcode.최원준;
+
+/*
+1. 아이디어 :
+row, col을 순회하면서 1을 만나게 되면 bfs를 수행
+bfs를 수행하면서 1을 0으로 바꿔준다
+
+2. 시간복잡도 :
+O( n*m )
+
+3. 자료구조/알고리즘 :
+- / bfs
+ */
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+public class Q200 {
+    class Solution {
+        char[][] grid;
+        int n, m;
+        int[] dx = {0,0,1,-1}, dy = {1,-1,0,0};
+
+        public void bfs(int row, int col) {
+            Deque<int[]> deque = new ArrayDeque<>();
+            deque.add(new int[]{row, col});
+
+            while (!deque.isEmpty()) {
+                int[] c = deque.pollFirst();
+                int x = c[0], y = c[1];
+                for (int i=0; i<4; i++) {
+                    int nx = x + dx[i], ny = y + dy[i];
+                    if (nx<0 || ny<0 || nx>=n || ny>=m || grid[nx][ny] == '0') continue;
+                    grid[nx][ny] = '0';
+                    deque.add(new int[]{nx, ny});
+                }
+            }
+        }
+
+        public int numIslands(char[][] grid) {
+            this.grid = grid;
+            n = grid.length;
+            m = grid[0].length;
+            int ans = 0;
+            for (int i=0; i<n; i++) for (int j=0; j<m; j++) {
+                if (grid[i][j] == '1') {
+                    ans++;
+                    bfs(i, j);
+                }
+            }
+            return ans;
+        }
+    }
+}