Merge pull request #1213 from Ujoonnee/main

[Ujoonnee] Week 02 solutions

Author: Ujoonnee

3sum/Ujoonnee.java

@@ -0,0 +1,87 @@
+import java.util.*;
+
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        Arrays.sort(nums);
+        Set<List<Integer>> set = new HashSet<>();
+        for(int i = 0; i < nums.length && nums[i] <= 0; i++) {
+            int j = i+1;
+            int k = nums.length - 1;
+            while(j < k) {
+                int sum = nums[i] + nums[j] + nums[k];
+                if (sum > 0) {
+                    k--;
+                    continue;
+                }
+
+                if (sum < 0) {
+                    j++;
+                    continue;
+                }
+
+                set.add(List.of(nums[i], nums[j], nums[k]));
+                j++;
+                k--;
+            }
+        }
+
+        return new ArrayList<>(set);
+    }
+}
+
+/*
+import java.util.*;
+import java.util.stream.Collectors;
+
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for(int i = 0; i < nums.length; i++) {
+            map.put(nums[i], i);
+        }
+
+        Set<Triplet> set = new HashSet<>();
+        for(int i = 0; i < nums.length; i++) {
+            int target = -nums[i];
+            for(int j = i+1; j < nums.length; j++) {
+                int operand = target - nums[j];
+                if (map.containsKey(operand) && map.get(operand) > j) {
+                    set.add(new Triplet(nums[i], nums[j], operand));
+                }
+            }
+        }
+
+        return set.stream().map(t -> List.of(t.triplet[0], t.triplet[1], t.triplet[2])).collect(Collectors.toList());
+    }
+}
+
+class Triplet {
+    int[] triplet;
+
+    Triplet(int first, int second, int third) {
+        this.triplet = new int[] { first, second, third };
+        Arrays.sort(triplet);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Triplet that)) {
+            return false;
+        }
+
+        for(int i = 0; i<3; i++) {
+            if (this.triplet[i] != that.triplet[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(triplet[0], triplet[1], triplet[2]);
+    }
+}
+*/

climbing-stairs/Ujoonnee.java

@@ -0,0 +1,16 @@
+class Solution {
+    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-2] + dp[i-1];
+        }
+
+        return dp[n];
+    }
+}

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

@@ -0,0 +1,58 @@
+/*
+# 목표 : i 전까지의 곱 * i 이후로의 곱
+## i 전까지의 곱
+- 0 : 1 (nums[0]은 이전 곱이 없으므로, 1 * (이후 곱)로 처리한다)
+- 1   : nums[0]
+- 2   : nums[0] * nums[1]
+- 3   : nums[0] * nums[1] * nums[2]
+- n-1 : nums[0] * nums[1] * ... * nums[n-1]
+
+### 매 단계 겹치는 부분을 저장한다. (before)
+- 0 : 1
+- 1 : before[0] * nums[0];
+- 2 : before[1] * nums[1];
+- 3 : before[2] * nums[2];
+=> O(n)
+
+## i 이후로의 곱
+- 0 : nums[1] * nums[2] * nums[3] ... nums[n-1]
+- 1 :           nums[2] * nums[3] ... nums[n-1]
+- 2 :                     nums[3] ... nums[n-1]
+...
+- n-1 : 1 (nums[n-1]은 이후 곱이 없으므로, (이전 곱) * 1로 처리한다)
+
+### 매 단계 겹치는 부분을 저장하되, 역순으로 반복해 저장한 값을 사용한다. (after)
+- n-1 : 1
+- n-2 : after[n-1] * nums[n-1]
+- n-3 : after[n-2] * nums[n-2]
+...
+- 0 : after[1] * nums[1]
+=> O(n)
+
+## before 와 after 의 값을 곱한다.
+=> O(n)
+*/
+
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        int n = nums.length;
+        int[] before = new int[n];
+        int[] after = new int[n];
+
+        before[0] = 1;
+        for(int i=1; i<n; i++) {
+            before[i] = before[i-1] * nums[i-1];
+        }
+
+        after[n-1] = 1;
+        for(int i=n-2; i>=0; i--) {
+            after[i] = after[i+1] * nums[i+1];
+        }
+
+        for(int i=0; i<n; i++) {
+            after[i] *= before[i];
+        }
+
+        return after;
+    }
+}

valid-anagram/Ujoonnee.java

@@ -0,0 +1,22 @@
+import java.util.Arrays;
+
+class Solution {
+    public boolean isAnagram(String s, String t) {
+        if (s.length() != t.length()) {
+            return false;
+        }
+
+        char[] sChar = s.toCharArray();
+        char[] tChar = t.toCharArray();
+        Arrays.sort(sChar);
+        Arrays.sort(tChar);
+
+        for(int i=0; i<sChar.length; i++) {
+            if (sChar[i] != tChar[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

validate-binary-search-tree/Ujoonnee.java

@@ -0,0 +1,24 @@
+/*
+time : O(n)
+space : O(n)
+
+최솟값과 최댓값의 범위를 정해 검증한다.
+*/
+
+class Solution {
+    public boolean isValidBST(TreeNode root) {
+        return valid(root, Long.MIN_VALUE, Long.MAX_VALUE);
+    }
+
+    boolean valid(TreeNode node, long min, long max) {
+        if (node == null) {
+            return true;
+        }
+
+        if (!(node.val > min && node.val < max)) {
+            return false;
+        }
+
+        return valid(node.left, min, node.val) && valid(node.right, node.val, max);
+    }
+}