[JeonJe] WEEK 02 Solutions

3sum/JeonJe.java

@@ -0,0 +1,41 @@
+import java.util.*;
+
+// TC: O(n^2)
+// SC: O(1)
+class Solution {
+
+    public List<List<Integer>> threeSum(int[] nums) {
+
+        List<List<Integer>> answer = new ArrayList<>();
+        int n = nums.length;
+        Arrays.sort(nums);
+
+        for (int x = 0; x < n - 2; x++) {
+            if (x > 0 && nums[x] == nums[x - 1]) continue;
+
+            int left = x + 1;
+            int right = n - 1;
+
+            while (left < right) {
+                if (nums[left] + nums[right] + nums[x] == 0) {
+                    answer.add(Arrays.asList(nums[x], nums[left], nums[right]));
+
+                    while (left + 1 < right && nums[left] == nums[left + 1]) {
+                        left++;
+                    }
+                    while (left < right - 1 && nums[right] == nums[right - 1]) {
+                        right--;
+                    }
+                    left++;
+                    right--;
+                } else if (nums[left] + nums[right] + nums[x] < 0) {
+                    left++;
+                } else {
+                    right--;
+                }
+            }
+        }
+
+        return answer;
+    }
+}

climbing-stairs/JeonJe.java

@@ -0,0 +1,31 @@
+import java.util.*;
+
+// TC: O(n)
+// SC: O(n)
+class Solution {
+    static int[] memo = new int[46];
+
+
+    public int climbStairs(int n) {
+
+        if (n == 1) return 1;
+        if (n == 2) return 2;
+        memo[1] = 1;
+        memo[2] = 2;
+
+        dfs(n);
+        return memo[n];
+    }
+
+    private int dfs(int num) {
+
+        //이미 계산한적이 있으면
+        if (memo[num] != 0) {
+            return memo[num];
+        }
+
+        memo[num] = dfs(num - 1) + dfs(num - 2);
+        return memo[num];
+
+    }
+}

product-of-array-except-self/JeonJe.java

@@ -0,0 +1,22 @@
+import java.util.*;
+
+// TC: O(n)
+// SC: O(1)
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        int n = nums.length;
+
+        int[] answer = new int[n];
+        answer[0] = 1;
+        for (int i = 1; i < n; i++) {
+            answer[i] = answer[i - 1] * nums[i - 1];
+        }
+
+        int right = 1;
+        for (int i = n - 2; i >= 0; i--) {
+            right = right * nums[i + 1];
+            answer[i] = answer[i] * right;
+        }
+        return answer;
+    }
+}

valid-anagram/JeonJe.java

@@ -0,0 +1,21 @@
+import java.util.*;
+
+// TC: O(n)
+// SC: O(1)
+class Solution {
+    public boolean isAnagram(String s, String t) {
+        if (s.length() != t.length()) return false;
+
+        int[] countS = new int[26];
+        int[] countT = new int[26];
+        for (int i = 0; i < s.length(); i++) {
+            countS[s.charAt(i) - 'a']++;
+            countT[t.charAt(i) - 'a']++;
+        }
+
+        for (int i = 0; i < 26; i++) {
+            if (countS[i] != countT[i]) return false;
+        }
+        return true;
+    }
+}

validate-binary-search-tree/JeonJe.java

@@ -0,0 +1,19 @@
+import java.util.*;
+
+// TC: O(n)
+// SC: O(h)
+class Solution {
+    public boolean isValidBST(TreeNode root) {
+        return isValid(root, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);
+    }
+
+    private boolean isValid(TreeNode node, double min, double max) {
+        if (node == null) {
+            return true;
+        }
+        if (node.val <= min || node.val >= max) {
+            return false;
+        }
+        return isValid(node.left, min, node.val) && isValid(node.right, node.val, max);
+    }
+}