Merge pull request DaleStudy#1155 from Yn3-3xh/main

[Yn3-3xh] WEEK 01 solutions

Author: Yn3-3xh

contains-duplicate/Yn3-3xh.java

@@ -0,0 +1,27 @@
+/*
+[문제풀이]
+time: O(N), space: O(N)
+- 같은 수가 하나라도 있으면 true
+- 모든 수가 다르면 false
+
+[회고]
+ArrayList vs Set
+ArrayList: O(N^2), 매번 리스트를 처음부터 검색해야 하며, n번 반복
+Set      : O(N)  , 내부적으로 해시 테이블을 사용하여 중복 확인을 O(1)에 수행
+따라서 중복 검사에서 Set 더 효율적
+
+set.add()의 return 자료형은 boolean 이다.
+이후에는 if(!set.add()) 처럼 사용해도 좋을 듯.
+*/
+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/Yn3-3xh.java

@@ -0,0 +1,73 @@
+/*
+[문제풀이]
+(X) 주어진 nums 배열에서 index 홀수의 합과 짝수의 합을 비교해보자.
+    class Solution {
+        public int rob(int[] nums) {
+            if (nums.length == 1) {
+                return nums[0];
+            }
+
+            for (int i = 1; i <= nums.length; i++) {
+                int beforeStepIndex = i - 2;
+                if (beforeStepIndex >= 1) {
+                    nums[i - 1] += nums[beforeStepIndex - 1];
+                }
+            }
+            return Math.max(nums[nums.length - 1], nums[nums.length - 2]);
+        }
+    }
+    >> 바로 옆이 아니어도 된다.
+
+(O) 현재 num과 이전 num을 비교하여, 큰 값을 기준으로 더한다.
+time: O(N), space: O(1)
+    class Solution {
+        public int rob(int[] nums) {
+            int prevNum = 0;
+            int sum = 0;
+            for (int num : nums) {
+                int temp = Math.max(sum, prevNum + num);
+                prevNum = sum;
+                sum = temp;
+            }
+            return sum;
+        }
+    }
+    >> 공간복잡도 최적화 솔루션으로, dp 보다 직관적이지 않아, 메모리 사용이 제한되거나 입력 크기가 매우 클 때 사용하는 것이 좋을 듯
+
+time: O(N), space: O(N)
+    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];
+        }
+    }
+    >> 공간복잡도는 좀 더 높지만, 직관적이다.
+[회고]
+개발은 혼자하는 것이 아니기도 하고, 디버깅하기 쉽게 직관적인 DP로 푸는게 좋지 않을까?..?
+*/
+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/Yn3-3xh.java

@@ -0,0 +1,37 @@
+/*
+[문제풀이]
+time: O(N), space: O(N)
+- 중복 제거
+- 연속된 횟수 max 구하기
+-- 연속된 숫자 그룹 중 첫번째부터 시작되도록
+
+[회고]
+연속된 숫자 그룹 중 첫번째부터 시작되도록 하는 부분에서 막혔다..
+차분히 생각해보면 무리없이 풀 수 있지 않았을까..
+*/
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        if (nums.length == 0) {
+            return 0;
+        }
+
+        Set<Integer> numsSet = new HashSet<>();
+        for (int num : nums) {
+            numsSet.add(num);
+        }
+
+        int maxCount = 1;
+        for (int num : numsSet) {
+            if (!numsSet.contains(num - 1)) {
+                int count = 1;
+                int currentNum = num;
+                while (numsSet.contains(currentNum + 1)) {
+                    count++;
+                    currentNum++;
+                }
+                maxCount = Math.max(maxCount, count);
+            }
+        }
+        return maxCount;
+    }
+}

top-k-frequent-elements/Yn3-3xh.java

@@ -0,0 +1,54 @@
+/*
+[문제풀이]
+time: O(N log N), space: O(N + k)
+- 주어진 Nums의 중복된 수의 갯수를 Map에 담고,
+- 역정렬하면,
+- k만큼 뽑기
+class Solution1 {
+    public int[] topKFrequent(int[] nums, int k) {
+        Map<Integer, Integer> counting = new HashMap<>();
+        for (int num: nums) {
+            int numCount = counting.getOrDefault(num, 0) + 1;
+            counting.put(num, numCount);
+        }
+
+        List<Map.Entry<Integer, Integer>> sortedCounting = new ArrayList<>(counting.entrySet());
+        sortedCounting.sort(Map.Entry.comparingByValue(Comparator.reverseOrder()));
+
+        int[] result = new int[k];
+        for (int i = 0; i < k; i++) {
+            result[i] = sortedCounting.get(i).getKey();
+        }
+
+        return result;
+    }
+}
+
+time: O(N log k), space: O(N + k)
+- PriorityQueue 사용
+- value로 역정렬 설정
+- key로 queue에 add
+
+[회고]
+첫번째 풀이는 역정렬 하는 부분이 미숙했고,
+두번째 풀이는 PriorityQueue를 사용하는데 처음 써본다.. (익히자!)
+*/
+class Solution {
+    public int[] topKFrequent(int[] nums, int k) {
+        Map<Integer, Integer> counting = new HashMap<>();
+        for (int num: nums) {
+            int numCount = counting.getOrDefault(num, 0) + 1;
+            counting.put(num, numCount);
+        }
+
+        Queue<Integer> queue = new PriorityQueue<>((count1, count2) ->
+                counting.get(count2) - counting.get(count1));
+        queue.addAll(counting.keySet());
+
+        int[] result = new int[k];
+        for (int i = 0; i < k; i++) {
+            result[i] = queue.poll();
+        }
+        return result;
+    }
+}

two-sum/Yn3-3xh.java

@@ -0,0 +1,31 @@
+/*
+[문제풀이]
+time: O(N), space: O(N)
+- nums 배열에 있는 두 수를 더한 값 = target
+- 더할 때 한 번씩만 사용
+
+[회고]
+O(N^2) 보다 줄일 수 있을까?
+결국 힌트3 까지 봐버렸다..
+
+nums 배열을 돌며 target-nums[i] 값을 key로, i를 value로, HashMap에 저장하면,
+배열을 돌다 해당 index의 값 nums[i]가 HashMap의 key와 일치하면,
+그 key의 value인 index를 뽑으면 된다.
+(Hash Table을 사용하면 키를 해싱하여 접근하기 때문에 조회가 빠르다!)
+
+유사한 문제가 나올 때 2중 for문이 이런 접근 방식이 먼저 떠올랐으면 좋겠다.
+*/
+
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> seen = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            int diff = target - nums[i];
+            if (seen.containsKey(diff)) {
+                return new int[]{seen.get(diff), i};
+            }
+            seen.put(nums[i], i);
+        }
+        return null;
+    }
+}