Merge branch 'DaleStudy:main' into main

Author: hozzijeong

3sum/8804who.py

@@ -0,0 +1,17 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        temp = {}
+        answer = {}
+        nums.sort()
+        for i in range(len(nums)):
+            for j in range(i+1, len(nums)):
+                if -(nums[i]+nums[j]) in temp:
+                    ans = str(nums[i])+','+str(nums[j])   
+                    answer[ans] = 1
+            temp[nums[i]] = 1
+        temp_ans = []
+        for ans in answer.keys():
+            s1, s2 = ans.split(',')
+            temp_ans.append([int(s1), int(s2), -(int(s1)+int(s2))])
+        return temp_ans
+    

3sum/Baekwangho.ts

@@ -0,0 +1,146 @@
+/**
+합산이 0이 되는 서로소 조합을 찾아야 한다.. 좌표가 다른 같은 값은 허용하되,
+같은 수로 구성된 조합은 중복을 불허한다.
+
+기본적으로 3가지 수를 중복없이 조합해서 뽑은 다음, 정렬을 사용하여 set 으로 구분할 수 있지 않을까?
+
+
+function threeSum(nums: number[]): number[][] {
+  const arraySet = new Set<string>();
+
+  for (let i = 0; i <= nums.length - 3; i++) {
+    for (let j = i + 1; j <= nums.length - 2; j++) {
+      for (let k = j + 1; k <= nums.length - 1; k++) {
+        if (nums[i] + nums[j] + nums[k] === 0) {
+          const sorted = [nums[i], nums[j], nums[k]];
+          sorted.sort((a, b) => a - b);
+          const string = sorted.join("#");
+          arraySet.add(string);
+        }
+      }
+    }
+  }
+
+  return Array.from(arraySet).map((el) =>
+    el.split("#").map((el) => Number(el))
+  );
+}
+ */
+
+/**
+시간 초과해버렸다. 어떻게 효율적으로 풀 수 있을까?
+two sum 을 보니 해시테이블을 쓴다고 한다. nums 를 해시테이블로 변환하고,
+이중 반복문에서 이를 활용해보자.
+
+function threeSum(nums: number[]): number[][] {
+  const arraySet = new Set<string>();
+  const hash = new Map<number, number[]>();
+  nums.forEach((val, idx) => {
+    const idxes = hash.get(val);
+    if (idxes && idxes.length) {
+      hash.set(val, [...idxes, idx]);
+    } else {
+      hash.set(val, [idx]);
+    }
+  });
+
+  for (let i = 0; i < nums.length - 2; i++) {
+    for (let j = i + 1; j < nums.length - 1; j++) {
+      const idxes = hash.get(0 - (nums[i] + nums[j]));
+
+      idxes?.forEach((idx) => {
+        if (idx != i && idx != j) {
+          const sorted = [nums[i], nums[j], nums[idx]];
+          sorted.sort((a, b) => a - b);
+          const string = sorted.join("#");
+          arraySet.add(string);
+        }
+      });
+    }
+  }
+
+  return Array.from(arraySet).map((el) =>
+    el.split("#").map((el) => Number(el))
+  );
+}
+
+ */
+
+/**
+... 0으로만 가득찬 배열에서 time limit 이 발생했다.
+풀이를 보고오니, 위 로직에서 0으로 가득찬 arraySet 을 순회하는 곳에서 결국 O(n^3) 이 되어버린다는 점을 확인할 수 있었다.
+확실한 것은, 정렬을 추가했을 경우 위 로직도 통과 가능한 정도로 만들어볼 수 있지 않을까 싶었다.
+
+function threeSum(nums: number[]): number[][] {
+  nums.sort((a, b) => a - b);
+  const arraySet = new Set<string>();
+  const hash = new Map<number, number[]>();
+
+  nums.forEach((val, idx) => {
+    const idxes = hash.get(val);
+    if (idxes && idxes.length) {
+      hash.set(val, [...idxes, idx]);
+    } else {
+      hash.set(val, [idx]);
+    }
+  });
+
+  for (let i = 0; i < nums.length - 2; i++) {
+    for (let j = i + 1; j < nums.length - 1; j++) {
+      const idxes = hash.get(0 - (nums[i] + nums[j])) ?? [];
+
+      for (let k = 0; k < idxes.length; k++) {
+        const idx = idxes[k];
+        if (idx != i && idx != j) {
+          const sorted = [nums[i], nums[j], nums[idx]];
+          sorted.sort((a, b) => a - b);
+          const string = sorted.join("#");
+          arraySet.add(string);
+
+          break;
+        }
+      }
+    }
+  }
+
+  return Array.from(arraySet).map((el) =>
+    el.split("#").map((el) => Number(el))
+  );
+}
+
+근데 어떻게든 못만듦.
+ */
+
+/**
+어제 해답을 보았으니, 다시한번 풀어보자.
+핵심은 투 포인터를 사용하는 것, 자료구조에 얽메이지 않는 것
+ */
+
+function threeSum(nums: number[]): number[][] {
+  nums.sort((a, b) => a - b);
+  const results = [];
+
+  // [-4, -1, -1, 0, 1, 2]
+  for (let i = 0; i < nums.length; i++) {
+    while (nums[i - 1] === nums[i]) i++;
+
+    let low = i + 1;
+    let high = nums.length - 1;
+    while (low < high) {
+      const sum = nums[i] + nums[low] + nums[high];
+      if (sum < 0) {
+        low++;
+      } else if (sum > 0) {
+        high--;
+      } else {
+        while (nums[high] === nums[high - 1]) high--;
+        while (nums[low] === nums[low + 1]) low++;
+        results.push([nums[i], nums[low], nums[high]]);
+        low++;
+        high--;
+      }
+    }
+  }
+
+  return results;
+}

3sum/Blossssom.ts

@@ -0,0 +1,49 @@
+/**
+ * @param nums - 정수 배열
+ * @returns - 세 요소를 합해 0이 되는 값의 배열
+ * @description
+ * - 투 포인터 방식
+ * - 결국 유니크한 조합을 찾으며 중복을 제외하는 방향
+ * - 무조건 적인 반복 줄이기가 아닌 효율적 범위 반복을 학습해야함
+ * - 시간 복잡도 O(N^2)
+ * - 공간 복잡도 O(log N)
+ */
+function threeSum(nums: number[]): number[][] {
+  const answer: number[][] = [];
+  nums.sort((a, b) => a - b);
+
+  for (let i = 0; i < nums.length - 2; i++) {
+    if (i && nums[i] === nums[i - 1]) {
+      continue;
+    }
+
+    let left = i + 1;
+    let right = nums.length - 1;
+
+    while (left < right) {
+      const sum = nums[i] + nums[left] + nums[right];
+
+      if (sum === 0) {
+        answer.push([nums[i], nums[left], nums[right]]);
+        while (left < right && nums[left] === nums[left + 1]) {
+          left++;
+        }
+        while (left < right && nums[right] === nums[right - 1]) {
+          right--;
+        }
+        left++;
+        right--;
+      } else if (sum < 0) {
+        left++;
+      } else {
+        right--;
+      }
+    }
+  }
+
+  return answer;
+}
+
+const nums = [-1, 0, 1, 2, -1, -4];
+threeSum(nums);
+

3sum/JangAyeon.js

@@ -0,0 +1,31 @@
+var threeSum = function (nums) {
+  let res = [];
+  nums.sort((a, b) => a - b);
+
+  for (let i = 0; i < nums.length; i++) {
+    if (i > 0 && nums[i] === nums[i - 1]) {
+      continue;
+    }
+
+    let j = i + 1;
+    let k = nums.length - 1;
+
+    while (j < k) {
+      let total = nums[i] + nums[j] + nums[k];
+
+      if (total > 0) {
+        k--;
+      } else if (total < 0) {
+        j++;
+      } else {
+        res.push([nums[i], nums[j], nums[k]]);
+        j++;
+
+        while (nums[j] === nums[j - 1] && j < k) {
+          j++;
+        }
+      }
+    }
+  }
+  return res;
+};

3sum/Seoya0512.py

@@ -0,0 +1,78 @@
+from typing import List
+
+'''
+1차 시도: 실패 (시간 초과)
+- nums에서 두 수 (A,B)를 고른 후, 세번째 숫자인 -(A+B)가 A,B를 제외한 nums에 존재하는지 확인
+- 중복된 결과를 제거하기 위해 set과 sorted(tuple)을 활용
+
+시간 복잡도: O(N^3)
+- Outer loop와 Inner loop 각각 O(N) 이므로 O(N^2)은 기본
+- nums[j:]에서 third_num을 찾는 데 O(N) 시간이 걸려서 전체 시간 복잡도는 O(N^3)
+
+공간 복잡도: 최대 O(N^2)
+- answer_set은 중복되지 않는 triplet을 저장하며, 3SUM 특성상 유니크한 triplet의 최대 개수는 O(N^2)
+
+'''
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        answer_set = set()
+
+        for i in range(len(nums) - 1):
+            for j in range(i + 1, len(nums)):
+                    third_num = -1 * (nums[i] + nums[j])   
+
+                    if third_num in nums[j:]:
+                        answer_set.add(tuple(sorted([nums[i], nums[j], third_num])))
+
+        return [list(t) for t in answer_set]
+
+'''
+개선 : if third_num in nums[j:] 부분을 set을 활용
+Approach
+- nums에서 두 수 (A,B)를 고른 후, 세번째 숫자인 -(A+B)가 존재하는지 확인하는 기존 기조는 유지함
+- (A,B) 쌍 중 ‘A(첫 번째 숫자)’가 동일한 값일 때,
+  이미 동일한 first 값으로 생성할 수 있는 모든 triplet을 처리했으므로
+  다시 같은 first로 시작하는 조합을 만들 필요가 없다는 점을 활용
+- seen set을 활용해서 (A,B)가 고정된 이후 세번째 숫자인 -(A+B)가 존재하는지 O(1) 시간에 확인
+
+- (예시) seen set은 i가 고정된 이후 j를 순회하면서 nums[j] 값을 저장
+- nums = [a, b, c, d, e]
+    - i = 0 (nums[i] = a)일 때, seen = {}
+    - j = 1 (nums[j] = b)일 때, seen = {b}
+    - j = 2 (nums[j] = c)일 때, seen = {b, c}
+    - j = 3 (nums[j] = d)일 때, seen = {b, c, d}
+    - j = 4 (nums[j] = e)일 때, seen = {b, c, d, e)
+
+시간 복잡도: O(N^2)
+- Outer loop와 Inner loop 각각 O(N) 이므로 전체 시간 복잡도는 O(N^2)
+
+공간 복잡도: 최대 O(N^2)
+- seen set은 nums[j]를 저장하며 최악의 경우 O(N)
+- used_first도 distinct first 값들을 저장하며 최대 O(N)
+- answer_set은 중복되지 않는 triplet을 저장하며, 3SUM 특성상 유니크한 triplet의 최대 개수는 O(N^2)
+'''
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        answer_set = set()
+        n = len(nums)
+
+        used_first = set()  # 이미 i로 사용한 값들
+
+        for i in range(n - 1):
+            # 같은 값을 첫 번째 숫자로 한 번만 쓰기
+            if nums[i] in used_first:
+                continue
+            used_first.add(nums[i])
+
+            seen = set()
+            for j in range(i + 1, n):
+                third_num = -1 * (nums[i] + nums[j])
+
+                if third_num in seen:
+                    triplet = tuple(sorted([nums[i], nums[j], third_num]))
+                    answer_set.add(triplet)
+                else:
+                    seen.add(nums[j])
+
+        return [list(t) for t in answer_set]

3sum/ZetBe.py

@@ -0,0 +1,43 @@
+'''
+문제: 중복되지 않는 세 수의 조합으로 합이 0이 되는 모든 경우를 찾기
+풀이: 정렬된 배열에서 첫 번째 수를 고정하고, 나머지 두 수를 투 포인터로 탐색
+시간복잡도: O(n^2)
+    배열을 정렬하는데 O(n log n), O(n)으로 순회하며 각 수에 대해 투 포인터로 나머지 두 수를 찾는데 O(n)이므로 전체 시간복잡도는 O(n^2)이다.
+공간복잡도: O(1)
+    추가적인 공간을 사용하지 않으므로 전체 공간복잡도는 O(1)이다.
+사용한 자료구조: 리스트
+
+별도의 회고: 정답에 중복된 조합이 들어가지 않도록 하기 위해,
+첫 번째 수를 고정할 때 이전 수와 같은 경우를 건너뛰고, 나머지 두 수를 찾을 때도 세 수의 합이 0일 경우, 각 두 동일한 수가 연속으로 나오는 경우를 건너뛰도록 하였다.
+'''
+
+import ast
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        answer = []
+        for i in range(len(nums)-2):
+            if i > 0 and nums[i-1] == nums[i]:
+                continue
+            l, r = i+1, len(nums)-1
+            while l < r:
+                if nums[i] + nums[l] + nums[r] == 0:
+                    arr = [nums[i], nums[l], nums[r]]
+                    answer.append(arr[:])
+                    while l < r and nums[l] == nums[l + 1]: 
+                        l+=1
+                    while l < r and nums[r] == nums[r - 1]: 
+                        r-=1
+                    l += 1
+                    r -= 1
+                elif nums[i] + nums[l] + nums[r] < 0:
+                    l += 1
+                else:
+                    r -= 1
+            
+        
+        
+
+        return answer
+    
+