[ohgyulim] WEEK 02 solutions

3sum/ohgyulim.java

@@ -0,0 +1,34 @@
+import java.util.*;
+
+class Solution {
+    /* 시간 복잡도: O(N^2)
+    * - for 루프: O(N)
+    *   - while 루프: O(N) -> N^2
+    * 공간 복잡도: O(K), answer의 K = List<Integer> 개수
+    */ 
+    public List<List<Integer>> threeSum(int[] nums) {
+        Arrays.sort(nums);
+
+        List<List<Integer>> answer = new ArrayList<>();
+        for (int i = 0; i < nums.length - 2; i++) {
+            if (i > 0 && nums[i] == nums[i - 1]) continue;
+
+            int left = i + 1;
+            int right = nums.length - 1;
+
+            while (left < right) {
+                int sum = nums[i] + nums[left] + nums[right];
+                if (sum == 0) {
+                    answer.add(List.of(nums[i], nums[left], nums[right]));
+                    while (left < right && nums[left] == nums[left + 1]) left += 1;
+                    while (left < right && nums[right] == nums[right - 1]) right -= 1;
+                    left += 1;
+                    right -= 1;
+                } else if (sum < 0) left += 1;
+                else right -= 1;
+            }
+        }
+
+        return answer;
+    }
+}

climbing-stairs/ohgyulim.java

@@ -0,0 +1,17 @@
+class Solution {
+    /* 시간 복잡도: O(N)
+    * - for 루프: O(N)
+    * 공간 복잡도: O(N), dp배열
+    */ 
+    public int climbStairs(int n) {
+        if (n == 1) return 1;
+        int[] dp = new int[n + 1];
+        dp[1] = 1;
+        dp[2] = 2;
+        for (int i = 3; i <= n; i++) {
+            dp[i] = dp[i - 1] + dp[i - 2];
+        }
+
+        return dp[n];
+    }
+}

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

@@ -0,0 +1,33 @@
+class Solution {
+    /* 시간 복잡도: O(N)
+    * - for 루프: O(N)
+    * 공간 복잡도: O(N), answer 배열
+    */ 
+    public int[] productExceptSelf(int[] nums) {
+        int product = 1;
+        int zeroCnt = 0;
+        for (int num : nums) {
+            if (num == 0) {
+                zeroCnt += 1;
+                continue;
+            }
+         product *= num;
+        }
+
+        int[] answer = new int[nums.length];
+        if (zeroCnt > 1) {
+            return answer;
+        }
+
+        for (int i = 0; i < nums.length; i++) {
+            int num = nums[i];
+            if (zeroCnt == 1) {
+                if (num == 0) answer[i] = product;
+            } else {
+                answer[i] = product / num;
+            }
+        }
+        return answer;
+    }
+}
+

valid-anagram/ohgyulim.java

@@ -0,0 +1,23 @@
+class Solution {
+    /* 시간 복잡도: O(N)
+    * - for 루프: O(N)
+    * 
+    * 공간 복잡도: O(52)
+    */ 
+    public boolean isAnagram(String s, String t) {
+        if (s.length() != t.length()) return false;
+
+        int[] sCounts = new int[26];
+        int[] tCounts = new int[26];
+        for (int i = 0; i < s.length(); i++) {
+            sCounts[s.charAt(i) - 'a'] += 1;
+            tCounts[t.charAt(i) - 'a'] += 1;
+        }
+
+        for (int i = 0; i < 26; i++) {
+            if (sCounts[i] != tCounts[i]) return false;
+        }
+
+        return true;
+    }
+}

validate-binary-search-tree/ohgyulim.java

@@ -0,0 +1,17 @@
+class Solution {
+    /* 시간 복잡도: O(N)
+    * - 재귀 호출: 트리 노드의 개수(N) 만큼
+    * 공간 복잡도: O(N)
+    * - 재귀 호출: 트리 노드의 개수(N) 만큼
+    */ 
+    public boolean isValidBST(TreeNode root) {
+        return validate(root, Long.MIN_VALUE, Long.MAX_VALUE);
+    }
+
+    boolean validate(TreeNode node, long min, long max) {
+        if (node == null) return true;
+        if (node.val <= min || node.val >= max) return false;
+        return validate(node.left, min, node.val) && validate(node.right, node.val, max);
+    }
+}
+