[jaekwang97] WEEK 02 Solutions (#2691)

* week 02 initial solutions

* product of array except self solution

* Add week 02 tree and three sum solutions

* Improve climbing stairs space usage

Author: JAEKWANG97

3sum/jaekwang97.java

@@ -0,0 +1,34 @@
+import java.util.*;
+
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        int n = nums.length;
+        Arrays.sort(nums);
+        List<List<Integer>> answers = new ArrayList<>();
+        Set<List<Integer>> answer = new HashSet<>();
+        for(int i = 0 ; i < n ; i++){
+            if (nums[i] > 0) break;
+            if (i > 0 && nums[i] == nums[i-1]) continue;
+            int left = i + 1;
+            int right = n - 1;
+            while(left < right){
+                int sum = nums[left] + nums[right] + nums[i];
+
+                
+                if (sum > 0) right--;
+                else if (sum < 0) left++;
+                else{
+                    answer.add(new ArrayList<>(List.of(nums[i],nums[left], nums[right])));
+                    while(left < right && nums[left] == nums[left+1]) left++;
+                    while(left < right && nums[right] == nums[right-1]) right--;
+                    left++;
+                    right--;
+                }
+            }
+        }
+        
+        answers = new ArrayList<>(answer);
+
+        return answers;
+    }
+}

climbing-stairs/jaekwang97.java

@@ -0,0 +1,16 @@
+class Solution {
+    public int climbStairs(int n) {
+        if (n <= 2) return n;
+
+        int prev = 1;
+        int cur = 2;
+
+        for (int i = 3; i <= n; i++) {
+            int next = prev + cur;
+            prev = cur;
+            cur = next;
+        }
+
+        return cur;
+    }
+}

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

@@ -0,0 +1,26 @@
+import java.util.*;
+
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        int n = nums.length;
+        int[] right = new int[n + 1];
+        int[] left = new int[n + 1];
+
+        right[0] = 1;
+        for (int i = 1; i <= n; i++) {
+            right[i] = right[i - 1] * nums[i - 1];
+        }
+
+        left[n] = 1;
+        for (int i = n - 1; i >= 0; i--) {
+            left[i] = left[i + 1] * nums[i];
+        }
+
+        int[] answer = new int[n];
+        for (int i = 0; i < n; i++) {
+            answer[i] = right[i] * left[i + 1];
+        }
+
+        return answer;
+    }
+}

valid-anagram/jaekwang97.java

@@ -0,0 +1,21 @@
+import java.util.*;
+
+class Solution {
+    public boolean isAnagram(String s, String t) {
+        int[] count = new int[26];
+
+        for (char c : s.toCharArray()) {
+            count[c - 'a']++;
+        }
+
+        for (char c : t.toCharArray()) {
+            count[c - 'a']--;
+        }
+
+        for (int n : count) {
+            if (n != 0) return false;
+        }
+
+        return true;
+    }
+}

validate-binary-search-tree/jaekwang97.java

@@ -0,0 +1,27 @@
+/**
+ * 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 {
+    public boolean isValidBST(TreeNode root) {
+        return dfs(root, Long.MIN_VALUE, Long.MAX_VALUE);
+    }
+
+    private boolean dfs(TreeNode node, long min, long max){
+        if(node == null) return true;
+        if(node.val <= min || node.val >= max) return false;
+
+        return dfs(node.left, min, node.val) && dfs(node.right, node.val, max);
+    }
+}