Merge branch 'DaleStudy:main' into main

Author: kimjunyoung90

3sum/haxr369.java

@@ -0,0 +1,64 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * 세 수의 인덱스가 모두 다르고 세 수 합이 0인 경우의 수를 구하기
+ * 세 숫자가 들어간 배열은 중복되게 하지 않은다.
+ * 
+ * 1. 모든 경우의 수를 구한다. => O(N^3)
+ * 3000*3000*3000 == 9*10^9 => 9억건...
+ * 2. left, mid, right라고 할 때, mid를 고정하고 left, right만 움직이는 two pointer를 응용하기
+ */
+class Solution {
+  /**
+   * Runtime: 545 ms (Beats 14.44%)
+   * Memory: 60.78 MB (Beats 5.38%)
+   * Space Complexity: O(N)
+   * - 정렬을 위한 공간 => O(N)
+   * - 세 수를 저장하기 위한 리스트 => O(3)
+   * > O(N) + O(3) => O(N)
+   * Time Complexity: O(NlogN)
+   * - 정렬을 위한 시간 => O(NlogN)
+   * - mid의 순회 => O(N)
+   * - two pointer 조회 => O(N)
+   * > O(NlogN) + O(N)*O(N) ~= O(N^2)
+   */
+  public List<List<Integer>> threeSum(int[] nums) {
+    int L = nums.length;
+    Arrays.sort(nums);
+
+    Set<List<Integer>> st = new HashSet<>();
+
+    // mid를 늘려가면서 투 포인터 진행
+    for (int mid = 1; mid < L - 1; mid++) {
+      int left = 0;
+      int right = L - 1;
+      while (left < mid && mid < right) {
+        int sm = nums[left] + nums[mid] + nums[right];
+        if (sm == 0) {
+          /**
+           * left를 더하는 이유:
+           * 현재 찾은 경우의 수 외에 다른 경우가 존재할 수 있음
+           * ex) -7,1,6 / -6,1,5
+           * => mid는 고정이지만, left는 늘리고 right를 줄여서 0을 만들 수 있는 다른 경우가 있음
+           */
+          List<Integer> li = new ArrayList<>();
+          li.add(nums[left]);
+          li.add(nums[mid]);
+          li.add(nums[right]);
+          st.add(li); // 중복값이 있어도 무시할 수 있음.
+          left++;
+        } else if (sm < 0) { // 부족하면 left 늘리기
+          left++;
+        } else { // 과하면 right 줄이기
+          right--;
+        }
+      }
+    }
+
+    return new ArrayList<>(st);
+  }
+}

3sum/ppxyn1.py

@@ -0,0 +1,32 @@
+# idea: sorting + two pointer
+# The idea was straightforward, but remove the duplication logic was the tricky.
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        n = len(nums)
+        answer = []
+
+        for i in range(n):
+            if i > 0 and  nums[i] == nums[i-1]:
+                continue
+
+            left, right = i+1, n-1
+
+            while left < right:
+                s = nums[i] + nums[left] + nums[right]
+                if s == 0:
+                    answer.append([nums[i], nums[left], nums[right]])
+                    while left < right and nums[left] == nums[left+1]:
+                        left += 1
+                    while left < right and nums[right] == nums[right-1]:
+                        right -= 1
+                    left += 1
+                    right -= 1
+                elif s < 0:
+                    left += 1
+                else:
+                    right -= 1
+        return answer
+
+

3sum/samcho0608.java

@@ -0,0 +1,66 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+// link: https://leetcode.com/problems/3sum/
+// difficulty: Medium
+class Solution {
+    // Problem:
+    // * return: all triplets of elements in nums such that the sum == 0 (indices must differ)
+    // Solution:
+    // * Time Complexity: O(N^2)
+    // * Space Complexity: O(1)
+    public List<List<Integer>> threeSum(int[] nums) {
+        // sort for simplicity
+        // Time Complexity: O(N log N)
+        Arrays.sort(nums);
+
+        List<List<Integer>> answers = new ArrayList<>();
+
+        // if there are only positive or only negative numbers, there exist no solution
+        if(nums[0] > 0 || nums[nums.length-1] < 0) return answers;
+
+
+
+        // Time Complexity: O(N^2)
+        // * for loop * inner while loop = O(N) * O(N) = O(N^2)
+
+        // nums[i]: first of the triplet
+        // * skip positive because the other two will also be positive
+        for(int i = 0; i < nums.length && nums[i] <= 0; i++) {
+            // skip if same first of the triplet met
+            if(i != 0 && nums[i] == nums[i-1]) continue;
+
+            int numI = nums[i];
+
+            int left = i + 1;
+            int right = nums.length - 1;
+
+            // Time Complexity: O(N)
+            while(left < right) {
+                int numLeft = nums[left];
+                int numRight = nums[right];
+
+                int sum = numI + numLeft + numRight;
+
+                if(sum == 0) {
+                    answers.add(Arrays.asList(numI, numLeft, numRight));
+
+                    // skip same lefts and rights two prevent duplicate
+                    // * must update both left and right
+                    //    * e.g. if only left is moved, newNumLeft = 0 - (numI + numRight) and that can only be numLeft that's already visited
+                    // * Time Complexity: O(1) because there is no actual operation other than skipping
+                    while(left < nums.length && nums[left] == numLeft) left++;
+
+                    while(right > left && nums[right] == numRight) right--;
+                } else if(sum > 0) {
+                    right--;
+                } else {
+                    left++;
+                }
+            }
+        }
+
+        return answers;
+    }
+}

3sum/unpo88.py

@@ -0,0 +1,192 @@
+class Solution:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
+        nums.sort()
+        result = set()
+
+        for i in range(len(nums) - 2):
+            # 양수인 경우 더 이상 탐색할 필요가 없음
+            if nums[i] > 0:
+                break
+            
+            # i 중복 skip
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            left = i + 1
+            right = len(nums) - 1
+            
+            while left < right:
+                total = nums[i] + nums[left] + nums[right]
+                
+                if total == 0:
+                    result.add((nums[i], nums[left], nums[right]))
+
+                    # 중복 건너뛰기
+                    while left < right and nums[left] == nums[left + 1]:
+                        left += 1
+                    # 중복 건너뛰기
+                    while left < right and nums[right] == nums[right - 1]:
+                        right -= 1
+                    left += 1
+                    right -= 1
+                elif total < 0:
+                    left += 1
+                else:
+                    right -= 1
+    
+        return [list(t) for t in result]
+
+    
+"""
+================================================================================
+풀이 과정 - 10:51 시작
+================================================================================
+
+1. 정수 배열 nums가 주어지면
+2. 모든 세 쌍 [nums[i], nums[j], nums[k]]을 반환해야한다
+3. i != j, i != k, j != k 여야하고
+4. nums[i] + nums[j] + nums[k] == 0 이어야한다
+5. 중복된 세 쌍이 포함되지 않아야한다
+
+
+[1차 시도] Brute Force 3중 반복문
+────────────────────────────────────────────────────────────────────────────────
+6. 제약을 무시하고 생각해보면 Brute Force 3중 반복문으로 찾을 수 있을 것 같음
+7. 중복도 제거해야하니까 마지막에 set을 두고 처리
+
+        result = []
+        n = len(nums)
+
+        for i in range(n):
+            for j in range(i+1, n):
+                for k in range(j+1, n):
+                    if nums[i] + nums[j] + nums[k] == 0:
+                        triplet = sorted([nums[i], nums[j], nums[k]])
+                        if triplet not in result:
+                            result.append(triplet)
+
+        return result
+
+8. Time Limit Exceeded 발생
+9. O(n³) 시간 복잡도로 너무 느림
+
+
+[2차 시도] Two Sum 응용 (HashSet)
+────────────────────────────────────────────────────────────────────────────────
+10. 3개를 동시에 찾으려니까 어려운 것 같은데
+11. 2개를 먼저 구하고, 나머지 하나를 더하면 0이 되는지를 확인해볼까
+12. 두 수의 합 = 나머지 하나의 값
+13. -nums[i] = nums[j] + nums[k]
+14. 그럼 Two Sum 문제로 풀 수 있을듯?
+15. 두 개의 합이 set에 존재하는지를 체크하는 형태로 가보자
+
+        result = set()
+
+        for i in range(len(nums)):
+            seen = set()
+            for j in range(i + 1, len(nums)):
+                complement = -(nums[i] + nums[j])
+                if complement in seen:
+                    result.add(tuple(sorted([nums[i], nums[j], complement])))
+                seen.add(nums[j])
+
+        return [list(x) for x in result]
+
+16. 아 근데 이것도 Time Limit Exceeded가 발생하네
+17. O(n²) 시간 복잡도로 개선했지만 sorted() 호출과 set 연산이 추가 비용 발생
+18. 다른 접근 방법이 필요할 듯
+
+
+[3차 시도] Two Pointer 방식
+────────────────────────────────────────────────────────────────────────────────
+19. 그럼 Two Pointer 방식으로 풀어야할 것 같은데
+20. Two Pointer 방식을 사용하려면 정렬이 필요함
+21. Two Sum의 Two Pointer 패턴을 생각해보자
+22. 근데 3개를 동시에 찾으려면 어떻게 해야할까?
+23. i를 고정하고, 나머지에서 Two Sum으로 합이 -nums[i]인 두 수를 찾는다!
+
+        정렬 전: [-1, 0, 1, 2, -1, -4]
+        정렬 후: [-4, -1, -1, 0, 1, 2]
+        index:    0   1   2  3  4  5
+
+        i = 0, left = i + 1, right = len(nums) - 1
+        [-4, -1, -1, 0, 1, 2]
+         i   L              R
+
+        i = 1:
+        [-4, -1, -1, 0, 1, 2]
+              i   L         R
+
+25. 정렬 먼저 한 후 합의 크기에 따라 포인터를 이동
+
+        nums.sort()
+        result = set()
+
+        for i in range(len(nums) - 2):
+            left = i + 1
+            right = len(nums) - 1
+
+            while left < right:
+                total = nums[i] + nums[left] + nums[right]
+
+                if total == 0:
+                    result.add((nums[i], nums[left], nums[right]))
+                    left += 1
+                    right -= 1
+                elif total < 0:
+                    left += 1
+                else:
+                    right -= 1
+
+        return [list(t) for t in result]
+
+25. O(n²) 시간 복잡도 (정렬 O(n log n) + 반복문 O(n²))
+26. 정상적으로 통과되는 것 확인 완료
+27. 근데 이 방식으로 풀었는데 느리다
+
+
+[4차 개선] 중복 제거 최적화
+────────────────────────────────────────────────────────────────────────────────
+28. Claude에게 물어보니 tuple 생성할 때 상수 배수가 큰 것 같다고 함
+29. 중복을 미리 스킵해주는 방법을 알려줌
+30. i가 양수인 경우 더 이상 탐색할 필요 없음 (정렬되어 있으므로)
+31. i, left, right 중복 건너뛰기 추가
+
+        nums.sort()
+        result = set()
+
+        for i in range(len(nums) - 2):
+            # 양수인 경우 더 이상 탐색할 필요가 없음
+            if nums[i] > 0:
+                break
+
+            # i 중복 skip
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            left = i + 1
+            right = len(nums) - 1
+
+            while left < right:
+                total = nums[i] + nums[left] + nums[right]
+
+                if total == 0:
+                    result.add((nums[i], nums[left], nums[right]))
+
+                    # 중복 건너뛰기
+                    while left < right and nums[left] == nums[left + 1]:
+                        left += 1
+                    while left < right and nums[right] == nums[right - 1]:
+                        right -= 1
+                    left += 1
+                    right -= 1
+                elif total < 0:
+                    left += 1
+                else:
+                    right -= 1
+
+        return [list(t) for t in result]
+
+32. 중복 처리 최적화로 속도 개선
+33. 최종 통과 확인 완료
+"""

climbing-stairs/haxr369.java

@@ -0,0 +1,38 @@
+class Solution {
+  /**
+   * 계산 n개를 오르기 위해 1 또는 2개씩 오르는 모든 경우의 수를 구하기
+   * 
+   * DP문제 풀이 과정
+   * 1. 문제 단순화
+   * - 숫자 N을 만들기 위해 1 또는 2를 더하는 순서를 만드는 경우의 수
+   * 2. 문제에서 원하는 것
+   * - N을 만들기 위한 모든 경우의 수
+   * => DP[N] = N을 만들기 위한 모든 경우의 수
+   * 2. 규칙 찾기
+   * - N은 N-1에서 1 더하거나, N-2에서 2를 더하면 도달할 수 있다.
+   * - 따라서 N에 도달하기 위한 경우의 수는 N-1을 도달하기 위한 경우의 수 + N-2에 도달하기 위한 경우의 수
+   * - DP[0] = 1 => 움직이지 않는다는 경우의 수
+   * - DP[1] = 1 => 1칸 움직이는 경우의 수
+   * - DP[N] = DP[N-2] + DP[N-1]
+   */
+  public int climbStairs(int n) {
+    /**
+     * Runtime: 0 ms (Beats 100.00%)
+     * Memory: 42.00 MB (Beats 15.00%)
+     * Space Complexity: O(N)
+     * - N 크기의 배열 1개 사용으로 O(N)
+     * > O(N)
+     * Time Complexity: O(N)
+     * - N회 덧셈으로 => O(N)
+     * > O(N)
+     */
+    int[] dp = new int[n + 1];
+    dp[0] = 1;
+    dp[1] = 1;
+
+    for (int i = 2; i < n + 1; i++) {
+      dp[i] = dp[i - 1] + dp[i - 2];
+    }
+    return dp[n];
+  }
+}