Merge pull request #689 from forest000014/main

[forest000014] Week 1

Author: forest000014

contains-duplicate/forest000014.java

@@ -0,0 +1,26 @@
+/*
+Runtime: 10 ms(Beats: 89.16 %)
+Time Complexity: O(n)
+- HashSet r/w : O(1)
+- nums iteration : ( O(1) + O(1) ) * n = O(n)
+
+Memory: 58.63 MB(Beats: 22.32 %)
+Space Complexity: O(n)
+*/
+
+
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+
+        for (int num: nums) {
+            if (set.contains(num)) {
+                return true;
+            }
+
+            set.add(num);
+        }
+
+        return false;
+    }
+}

house-robber/forest000014.java

@@ -0,0 +1,62 @@
+class Solution {
+    /*
+        [1, i]의 범위에서 최대값을 구하고자 할 때, 만약 [1, i-1]의 범위에서의 최대값을 이미 계산해 놓았다면 O(1)에 계산할 수 있다는 아이디어에서 출발합니다.
+        단, 연속해서 두 집에서 훔칠 수 없다는 전제조건이 있으므로, i-1번째 집에서 훔친 경우와 훔치지 않는 경우 각각에 대한 최대값을 따로 구해두어야 합니다.
+        dp[i-1][0]에는 i-1번째 집에서 훔치지 않는 경우의 최대값, dp[i-1][1]에는 i-1번째 집에서 훔친 경우의 최대값이 저장되어 있다는 전제하에,
+        dp[i][0], dp[i][1]을 아래와 같이 구할 수 있습니다.
+
+        1) i번째 집에서 훔치지 않는 경우의 [1, i] 범위에서의 최대값
+        i번째 집에서는 훔치지 않을 것이므로, [1, i-1] 범위에서의 최대값이 dp[i][0]이 됩니다.
+        단, 여기서 주의할 점은 dp[i-1][1]이 무조건 dp[i-1][0] 이상이라고 착각할 수 있다는 건데요,
+        {100, 1, 1, 100} 에서 dp[1][0] = 100, dp[1][1] = 1 이라는 케이스를 생각해보면, dp[i-1][0], dp[i-1][1]를 비교해서 큰 것을 선택해야 함을 알 수 있습니다.
+
+        2) i번째 집에서 훔치는 경우의 [1, i] 범위에서의 최대값
+        i번째 집에서 훔치기 위해서는, i-1번째 집에서는 훔치지 않았어야만 합니다.
+        따라서 단순히 dp[i][1] = dp[i-1][0] + nums[i] 가 됩니다.
+
+        Runtime: 0 ms(Beats: 100.00 %)
+        Time Complexity: O(n)
+        - nums iteration : O(n)
+
+        Memory: 41.04 MB(Beats: 43.05 %)
+        Space Complexity: O(n)
+        - dp[n][2] : O(n) * 2 = O(n)
+    */
+    public int rob(int[] nums) {
+        int[][] dp = new int[nums.length][2];
+
+        dp[0][1] = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1]);
+            dp[i][1] = dp[i - 1][0] + nums[i];
+        }
+
+        return Math.max(dp[nums.length - 1][0], dp[nums.length - 1][1]);
+    }
+
+    /*
+        생각해보니 memoization 배열을 굳이 들고다닐 필요가 없어서,
+        필요한 값(직전 인덱스에서의 memoization 값)만 저장하도록 수정해서 공간 복잡도를 개선했습니다.
+        그런데... 무슨 이유에선지 오히려 메모리 사용량은 더 증가했다고 나오네요...?
+
+        Runtime: 0 ms(Beats: 100.00 %)
+        Time Complexity: O(n)
+        - nums iteration : O(n)
+
+        Memory: 41.21 MB(Beats: 22.01 %)
+        Space Complexity: O(1)
+    */
+    public int rob2(int[] nums) {
+        int[] dp = new int[2];
+
+        dp[1] = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            int tmp0 = Math.max(dp[0], dp[1]);
+            int tmp1 = dp[0] + nums[i];
+            dp[0] = tmp0;
+            dp[1] = tmp1;
+        }
+
+        return Math.max(dp[0], dp[1]);
+    }
+}

longest-consecutive-sequence/forest000014.java

@@ -0,0 +1,70 @@
+/*
+sol 1. 재귀 호출
+
+알고리즘 문제를 오랜만에 풀어서... union-find를 떠올리긴 했으나, 구현 방법이 가물가물해서 원하는 솔루션으로 풀지 못한 것 같습니다.
+일단 vis, cnt 와 재귀 호출을 사용해서 union-find와 유사하게 구현하긴 했는데요 (해설을 달면서 다시 보니 이것도 union-find를 구현하는 한 방법이라고 할 수 있을듯...?),
+시간이 된다면 좀 더 최적화한 솔루션을 제출해보겠습니다.
+
+Runtime: 98 ms(Beats: 35.68 %)
+Time Complexity: O(n)
+- set, vis, cnt 생성 : O(n)
+- set의 모든 원소를 순회하면서 checkAbove 수행 : O(n)
+    - checkAbove(x)는 x를 1번째 원소로 하는, 증가하는 연속 수열의 길이를 반환함
+    - checkAbove(x)는 재귀적으로 checkAbove(x + 1)을 호출함.
+    - checkAbove(x)는 이미 x를 방문한 적이 있거나, set 안에 x가 존재하지 않는 경우가 base case
+    - 따라서 set의 모든 원소를 순회하는 iteration에서, n + a번 호출되므로, 시간 복잡도는 O(n)
+        - (a는 consecutive chunk의 개수이고 n보다 작거나 같음)
+
+
+Memory: 118.04 MB(Beats: 5.60 %)
+Space Complexity: O(n)
+- set, vis, cnt : O(n)
+ */
+
+class Solution {
+    Set<Integer> set = new HashSet<>();
+    Map<Integer, Boolean> vis = new HashMap<>();
+    Map<Integer, Integer> cnt = new HashMap<>(); // key를 1번째 원소로 하는 연속한 증가 수열의 크기
+
+    public int longestConsecutive(int[] nums) {
+        if (nums.length == 0) {
+            return 0;
+        }
+
+        for (int num : nums) {
+            if (set.contains(num)) {
+                continue;
+            }
+
+            set.add(num);
+            vis.put(num, false);
+            cnt.put(num, 1);
+        }
+
+        int max = 0;
+        for (int num : set) {
+            int cnt = checkAbove(num);
+            if (max < cnt) {
+                max = cnt;
+            }
+        }
+
+        return max;
+    }
+
+    public Integer checkAbove(Integer num) {
+        if (null == vis.get(num)) {
+            return 0;
+        } else if (vis.get(num)) {
+            return cnt.get(num);
+        }
+
+        vis.put(num, true);
+        int cntAbove = checkAbove(num + 1);
+        if (cntAbove > 0) {
+            cnt.put(num, cntAbove + 1);
+        }
+
+        return cntAbove + 1;
+    }
+}

top-k-frequent-elements/forest000014.java

@@ -0,0 +1,52 @@
+/*
+Runtime: 10 ms(Beats: 95.83 %)
+Time Complexity: O(nlogn)
+- map에 item 추가 : O(n)
+- items 배열 정렬 : O(nlogn)
+- result 배열에 원소 추가 : O(n)
+
+Memory: 49.50 MB(Beats: 6.84 %)
+Space Complexity: O(n)
+- map : O(n)
+- items : O(n)
+- result : O(n)
+*/
+
+class Solution {
+    class Item {
+        int val;
+        int cnt;
+
+        public Item(int val, int cnt) {
+            this.val = val;
+            this.cnt = cnt;
+        }
+
+        public void plusOne() {
+            this.cnt += 1;
+        }
+    }
+
+    public int[] topKFrequent(int[] nums, int k) {
+        Map<Integer, Item> map = new HashMap<>();
+        for (int num : nums) {
+            Item item = map.get(num);
+            if (item == null) {
+                item = new Item(num, 1);
+                map.put(num, item);
+            } else {
+                item.plusOne();
+            }
+        }
+
+        ArrayList<Item> items = new ArrayList<>(map.values());
+        Collections.sort(items, (item1, item2) -> Integer.compare(item2.cnt, item1.cnt));
+
+        int[] result = new int[k];
+        for (int i = 0; i < k; i++) {
+            result[i] = items.get(i).val;
+        }
+
+        return result;
+    }
+}

valid-palindrome/forest000014.java

@@ -0,0 +1,39 @@
+/*
+Runtime: 2 ms(Beats: 99.10 %)
+Time Complexity: O(n)
+
+Memory: 42.75 MB(Beats: 85.31 %)
+Space Complexity: O(1)
+... 문제에서 주어진 String s는 space complexity 계산에서 제외하고, 제가 추가한 변수에 대해서만 계산하면 될까요?
+
+ps. 처음 풀이에서는 alphanumeric 여부와 대소문자 관련 로직을 일일이 구현했다가, isLetterOrDigit(), toLowerCase()로 변경했습니다.
+*/
+
+class Solution {
+    public boolean isPalindrome(String s) {
+        for (int i = 0, j = s.length() - 1; i < j; i++, j--) {
+            char a = s.charAt(i);
+            while (!Character.isLetterOrDigit(a)) {
+                a = s.charAt(++i);
+                if (i >= j) {
+                    return true;
+                }
+            }
+            a = Character.toLowerCase(a);
+
+            char b = s.charAt(j);
+            while (!Character.isLetterOrDigit(b)) {
+                b = s.charAt(--j);
+                if (i >= j) {
+                    return true;
+                }
+            }
+            b = Character.toLowerCase(b);
+
+            if (a != b) {
+                return false;
+            }
+        }
+        return true;
+    }
+}