Merge branch 'DaleStudy:main' into main

Author: yolophg

3sum/bky373.java

@@ -0,0 +1,37 @@
+/**
+ * time: O(n^2)
+ * space: O(n)
+ *
+ * - time: becasue of two nested loop and inner loop having a linear time complexity.
+ * - space: because of a HashSet to store the triplets.
+ */
+class Solution {
+
+    public List<List<Integer>> threeSum(int[] nums) {
+        Arrays.sort(nums);
+        int i = 0, j, k;
+        int ni = 0, nj, nk;
+        Set<List<Integer>> res = new HashSet<>();
+        while (i < nums.length && ni <= 0) {
+            ni = nums[i];
+            j = i + 1;
+            k = nums.length - 1;
+            while (j < k) {
+                nj = nums[j];
+                nk = nums[k];
+                int sum = ni + nj + nk;
+                if (sum < 0) {
+                    j++;
+                } else if (sum > 0) {
+                    k--;
+                } else {
+                    res.add(List.of(ni, nj, nk));
+                    j++;
+                }
+            }
+            i++;
+        }
+        return res.stream()
+                  .toList();
+    }
+}

container-with-most-water/dev-jonghoonpark.md

@@ -0,0 +1,38 @@
+- 문제: https://leetcode.com/problems/container-with-most-water/
+- time complexity : O(n)
+- space complexity : O(1)
+- 블로그 주소 : https://algorithm.jonghoonpark.com/2024/06/02/leetcode-11
+
+```java
+class Solution {
+    public int maxArea(int[] height) {
+        int start = 0;
+        int end = height.length - 1;
+
+        int max = getArea(height, start, end);
+
+        while(start < end) {
+            if(height[start] >= height[end]) {
+                end--;
+                max = Math.max(max, getArea(height, start, end));
+            } else {
+                start++;
+                max = Math.max(max, getArea(height, start, end));
+            }
+        }
+
+        return max;
+    }
+
+    public int getArea(int[] height, int start, int end) {
+        if (start == end) {
+            return 0;
+        }
+        return getMinHeight(height[end], height[start]) * (end - start);
+    }
+
+    public int getMinHeight(int height1, int height2) {
+        return Math.min(height1, height2);
+    }
+}
+```

encode-and-decode-strings/bky373.java

@@ -0,0 +1,30 @@
+/**
+ * time: O(N)
+ * space: O(N)
+ */
+public class Codec {
+
+    // Encodes a list of strings to a single string.
+    public String encode(List<String> strs) {
+        StringBuilder sb = new StringBuilder();
+        for (String str : strs) {
+            sb.append(str.length())
+              .append(':')
+              .append(str);
+        }
+        return sb.toString();
+    }
+
+    // Decodes a single string to a list of strings.
+    public List<String> decode(String s) {
+        List<String> decoded = new ArrayList<>();
+        int i = 0;
+        while (i < s.length()) {
+            int searchIndex = s.indexOf(':', i);
+            int chunkSize = Integer.parseInt(s.substring(i, searchIndex));
+            i = searchIndex + chunkSize + 1;
+            decoded.add(s.substring(searchIndex + 1, i));
+        }
+        return decoded;
+    }
+}

find-minimum-in-rotated-sorted-array/dev-jonghoonpark.md

@@ -0,0 +1,21 @@
+- 문제: https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/
+- time complexity : O(log n)
+- space complexity : O(1)
+- 블로그 주소 : https://algorithm.jonghoonpark.com/2024/06/03/leetcode-153
+
+```java
+public int findMin(int[] nums) {
+    int left = 0, right = nums.length - 1;
+    while(left < right) {
+        int mid = left + (right - left) / 2;
+
+        if(nums[mid] < nums[right]) {
+            right = mid;
+        } else {
+            left = mid + 1;
+        }
+    }
+
+    return nums[left];
+}
+```

longest-consecutive-sequence/bky373.java

@@ -0,0 +1,25 @@
+/**
+ * time: O(N)
+ * space: O(N)
+ */
+class Solution {
+
+    public int longestConsecutive(int[] nums) {
+        Set<Integer> numSet = new HashSet<>();
+        for (int n : nums) {
+            numSet.add(n);
+        }
+        int longest = 0;
+        for (int n : nums) {
+            if (numSet.contains(n - 1)) {
+                continue;
+            }
+            int seq = 1;
+            while (numSet.contains(n + seq)) {
+                seq++;
+            }
+            longest = Math.max(longest, seq);
+        }
+        return longest;
+    }
+}

longest-repeating-character-replacement/dev-jonghoonpark.md

@@ -0,0 +1,36 @@
+- 문제: https://leetcode.com/problems/longest-repeating-character-replacement/
+- time complexity : O(n)
+- space complexity : O(1)
+- 블로그 주소 : https://algorithm.jonghoonpark.com/2024/04/29/leetcode-424
+
+```java
+class Solution {
+    public int characterReplacement(String s, int k) {
+        int[] counter = new int[26];
+        int countOfMostFrequent = -1;
+
+        int headPointer = 0;
+        int tailPointer = 0;
+
+        int maxLength = 0;
+
+        while (headPointer < s.length()) {
+            char head = s.charAt(headPointer);
+            char tail = s.charAt(tailPointer);
+            counter[head - 'A']++;
+            headPointer++;
+
+            countOfMostFrequent = Math.max(counter[head - 'A'], countOfMostFrequent);
+            while (headPointer - tailPointer > countOfMostFrequent + k) {
+                counter[tail - 'A']--;
+                tailPointer++;
+                tail = s.charAt(tailPointer);
+            }
+
+            maxLength = Math.max(maxLength, headPointer - tailPointer);
+        }
+
+        return maxLength;
+    }
+}
+```

longest-substring-without-repeating-characters/dev-jonghoonpark.md

@@ -0,0 +1,34 @@
+- 문제: https://leetcode.com/problems/longest-substring-without-repeating-characters/
+- time complexity : O(n)
+- space complexity : O(n)
+- 블로그 주소 : https://algorithm.jonghoonpark.com/2024/02/18/leetcode-3
+
+```java
+class Solution {
+    public int lengthOfLongestSubstring(String s) {
+        if (s.isEmpty()) {
+            return 0;
+        }
+
+        Set<Character> set = new HashSet<>();
+        int pointer = 0;
+        int longest = 0;
+
+        while (pointer < s.length()) {
+            char _char = s.charAt(pointer);
+            while (set.contains(_char)) {
+                set.remove(s.charAt(pointer - set.size()));
+            }
+            set.add(_char);
+            longest = Math.max(longest, set.size());
+            pointer++;
+        }
+
+        return longest;
+    }
+}
+```
+
+## TC 추가 설명
+
+내부 while이 있지만 O(n)으로 적을 수 있는 이유는 hashset의 경우 search 하는데 드는 비용이 O(1) 이기 때문이다.

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

@@ -0,0 +1,24 @@
+/**
+ * time: O(N)
+ * space: O(N)
+ */
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        int len = nums.length;
+        int[] res = new int[len];
+        int[] left = Arrays.copyOf(nums, len);
+        int[] right = Arrays.copyOf(nums, len);
+        for (int i = 1; i < len; i++) {
+            left[i] *= left[i - 1];
+        }
+        for (int i = len - 2; i >= 0; i--) {
+            right[i] *= right[i + 1];
+        }
+        for (int i = 1; i < len - 1; i++) {
+            res[i] = left[i - 1] * right[i + 1];
+        }
+        res[0] = right[1];
+        res[len - 1] = left[len - 2];
+        return res;
+    }
+}

search-in-rotated-sorted-array/dev-jonghoonpark.md

@@ -0,0 +1,33 @@
+- 문제: https://leetcode.com/problems/search-in-rotated-sorted-array/
+- time complexity : O(log n)
+- space complexity : O(1)
+- 블로그 주소 : https://algorithm.jonghoonpark.com/2024/06/03/leetcode-33
+
+```java
+public int search(int[] nums, int target) {
+    int left = 0, right = nums.length - 1;
+    while(left <= right) {
+        int mid = left + (right - left) / 2;
+
+        if (nums[mid] == target) {
+            return mid;
+        }
+
+        if(nums[mid] < nums[right]) {
+            if (target < nums[mid] || target > nums[right]) {
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        } else {
+            if (target < nums[left] || target > nums[mid]) {
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+    }
+
+    return -1;
+}
+```

top-k-frequent-elements/bky373.java

@@ -0,0 +1,26 @@
+/**
+ * time: O(N log k)
+ * space: O(N + k)
+ *
+ * - time: N 개를 순회하며 heap 에 요소 추가, 최대 k 개만큼 요소를 추가하여 log k 만큼 시간이 곱해짐.
+ * - space: 빈도 수를 저장하기 위해 N, 힙에 요소를 저장하기 위해 K 만큼 저장 공간을 사용함.
+ */
+class Solution {
+
+    public int[] topKFrequent(int[] nums, int k) {
+        Map<Integer, Integer> freqMap = new HashMap<>();
+        for (int n : nums) {
+            freqMap.put(n, freqMap.getOrDefault(n, 0) + 1);
+        }
+        Queue<Integer> pq = new PriorityQueue<>(Comparator.comparingInt(freqMap::get));
+        for (Integer n : freqMap.keySet()) {
+            pq.add(n);
+            if (pq.size() > k) {
+                pq.poll();
+            }
+        }
+        return IntStream.range(0, k)
+                        .map(i -> pq.poll())
+                        .toArray();
+    }
+}