[xeulbn] WEEK 02 solutions

3sum/xeulbn.java

@@ -0,0 +1,52 @@
+import java.util.*;
+
+//시간복잡도 : O(n^2), 공간복잡도 : O(nlogn)
+
+class Solution {
+    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 leftIndex = i+1;
+            int rightIndex = nums.length-1;
+
+            while(leftIndex<rightIndex){
+                int sum =nums[i]+nums[leftIndex]+nums[rightIndex];
+
+                if(sum==0){
+                    // 정답 추가
+                    List<Integer> tmpList = new ArrayList<>();
+                    tmpList.add(nums[i]);
+                    tmpList.add(nums[leftIndex]);
+                    tmpList.add(nums[rightIndex]);
+
+                    answer.add(tmpList);
+
+                    // left++, right--
+                    leftIndex+=1;
+                    rightIndex-=1;
+
+                    // 중복 제거
+                    while(leftIndex<rightIndex && nums[leftIndex]==nums[leftIndex-1]){
+                        leftIndex+=1;
+                    }
+                    while(leftIndex<rightIndex && nums[rightIndex]==nums[rightIndex+1]){
+                        rightIndex-=1;
+                    }
+
+                }else if(sum<0){
+                    leftIndex+=1;
+                }else{
+                    rightIndex-=1;
+                }
+            }
+        }
+
+        return answer;
+    }
+}

climbing-stairs/xeulbn.java

@@ -0,0 +1,23 @@
+import java.util.*;
+
+//시간복잡도 : O(n), 공간복잡도 : O(n)
+//이전 두 값만 필요하기에, 공간복잡도는 O(1)까지 최적화가 가능.
+
+class Solution {
+    public int climbStairs(int n) {
+        if(n<=2){
+            return n;
+        }
+
+        int[] dp =new int[n+1];
+        dp[1]=1;
+        dp[2]=2;
+
+        for(int i=3;i<n+1;i++){
+            dp[i]=dp[i-1]+dp[i-2];
+        }
+
+        return dp[n];
+
+    }
+}

contains-duplicate/xeulbn.java

@@ -0,0 +1,15 @@
+import java.util.*;
+
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> numberCheck = new HashSet<>();
+
+        for(int num : nums){
+            if(numberCheck.contains(num)){
+                return true;
+            }
+            numberCheck.add(num);
+        }
+        return false;
+    }
+}

house-robber/xeulbn.java

@@ -0,0 +1,21 @@
+import java.util.*;
+
+class Solution {
+
+    public int rob(int[] nums) {
+        if (nums.length == 1) {
+            return nums[0];
+        }
+
+        int[] dp = new int[nums.length];
+
+        dp[0] = nums[0];
+        dp[1] = Math.max(nums[0], nums[1]);
+
+        for (int i = 2; i < nums.length; i++) {
+            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
+        }
+
+        return dp[nums.length - 1];
+    }
+}

longest-consecutive-sequence/xeulbn.java

@@ -0,0 +1,29 @@
+import java.util.*;
+
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+
+        for (int num : nums) {
+            set.add(num);
+        }
+
+        int maxLength = 0;
+
+        for (int num : set) {
+            if (!set.contains(num - 1)) {
+                int currentNum = num;
+                int currentLength = 1;
+
+                while (set.contains(currentNum + 1)) {
+                    currentNum++;
+                    currentLength++;
+                }
+
+                maxLength = Math.max(maxLength, currentLength);
+            }
+        }
+
+        return maxLength;
+    }
+}

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

@@ -0,0 +1,23 @@
+import java.util.*;
+
+//시간 복잡도 O(n), 공간 복잡도 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 suffix = 1;
+        for (int i = n-1; i >= 0; i--) {
+            answer[i] = answer[i] * suffix;
+            suffix *= nums[i];
+        }
+
+        return answer;
+    }
+}

top-k-frequent-elements/xeulbn.java

@@ -0,0 +1,31 @@
+import java.util.*;
+
+class Solution {
+    public int[] topKFrequent(int[] nums, int k) {
+        Map<Integer,Integer> countMap = new HashMap<>();
+
+        for(int i=0;i<nums.length;i++){
+            countMap.put(nums[i],countMap.getOrDefault(nums[i],0)+1);
+        }
+        PriorityQueue<Integer> pq = new PriorityQueue<>(
+                (a,b)-> countMap.get(a) - countMap.get(b)
+        );
+
+        for(int num: countMap.keySet()){
+            pq.offer(num);
+
+            if(pq.size()>k){
+                pq.poll();
+            }
+        }
+
+        int[] answer = new int[k];
+
+        for (int i = 0; i < k; i++) {
+            answer[i] = pq.poll();
+        }
+
+        return answer;
+
+    }
+}

two-sum/xeulbn.java

@@ -0,0 +1,17 @@
+import java.util.*;
+
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> numIndexMap = new HashMap<>();
+
+        for (int i=0; i<nums.length; i++) {
+            int need = target - nums[i];
+            if (numIndexMap.containsKey(need)) {
+                return new int[]{numIndexMap.get(need), i};
+            }
+            numIndexMap.put(nums[i], i);
+        }
+
+        return new int[]{};
+    }
+}

valid-anagram/xeulbn.java

@@ -0,0 +1,33 @@
+import java.util.*;
+
+// 시간복잡도 : O(n), 공간복잡도 : O(n)
+
+class Solution {
+    public boolean isAnagram(String s, String t) {
+
+        if(s.length()!=t.length()){
+            return false;
+        }
+
+        Map<Character,Integer> characterMap = new HashMap<>();
+
+        for(int i=0;i<s.length();i++){
+            char c = s.charAt(i);
+            characterMap.put(c,characterMap.getOrDefault(c,0)+1);
+        }
+
+        for(int i=0;i<t.length();i++){
+            char c = t.charAt(i);
+
+            if(!characterMap.containsKey(c)){
+                return false;
+            }
+
+            characterMap.put(c, characterMap.get(c) - 1);
+            if(characterMap.get(c)<0){
+                return false;
+            }
+        }
+        return true;
+    }
+}

validate-binary-search-tree/xeulbn.java

@@ -0,0 +1,39 @@
+import java.util.*;
+
+
+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 validate(root, Long.MIN_VALUE, Long.MAX_VALUE);
+    }
+
+    private 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);
+    }
+}