Merge branch 'DaleStudy:main' into main

Author: Lustellz

3sum/soobing2.ts

@@ -0,0 +1,42 @@
+/**
+ * 문제 유형
+ * - Array (정렬 + 투포인터)
+ * 
+ * 문제 설명
+ * - 3개의 수를 더해서 0이 되는 경우를 찾아서 배열로 반환하기
+ * 
+ * 아이디어
+ * 1) 정렬 후 투포인터 사용, 중복 제거
+ 
+ */
+function threeSum(nums: number[]): number[][] {
+  const result: number[][] = [];
+
+  // sorting
+  nums.sort((a, b) => a - b);
+
+  for (let i = 0; i < nums.length - 2; i++) {
+    // 중복 제거
+    if (i > 0 && 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) {
+        result.push([nums[i], nums[left], nums[right]]);
+        left++;
+        right--;
+
+        // 중복 제거
+        while (left < right && nums[left] === nums[left - 1]) left++;
+        while (left < right && nums[right] === nums[right + 1]) right--;
+      } else if (sum < 0) {
+        left++;
+      } else {
+        right--;
+      }
+    }
+  }
+  return result;
+}

climbing-stairs/soobing.ts

@@ -0,0 +1,34 @@
+/**
+ * 문제 유형
+ * - DP (피보나치)
+ *
+ * 문제 설명
+ * - 계단을 올라가는 방법의 수를 구하기
+ *
+ * 아이디어
+ * 1) 피보나치 수열 활용
+ * - climbStairs(n) = climbStairs(n-1) + climbStairs(n-2)
+ */
+function climbStairsBottomUp(n: number): number {
+  function fibonacci(n: number, memo = new Map<number, number>()) {
+    if (n === 1) return 1;
+    if (n === 2) return 2;
+
+    if (memo.has(n)) return memo.get(n);
+    const result = fibonacci(n - 1, memo) + fibonacci(n - 2, memo);
+    memo.set(n, result);
+    return result;
+  }
+  return fibonacci(n);
+}
+
+function climbStairsTopDown(n: number): number {
+  const dp = new Array(n + 1).fill(0);
+  dp[1] = 1;
+  dp[2] = 2;
+
+  for (let i = 3; i <= n; i++) {
+    dp[i] = dp[i - 1] + dp[i - 2];
+  }
+  return dp[n];
+}

combination-sum/delight010.swift

@@ -0,0 +1,24 @@
+class Solution {
+    func combinationSum(_ candidates: [Int], _ target: Int) -> [[Int]] {
+        var result: [[Int]] = []
+        var current: [Int] = []
+        findCombination(0, target, candidates, &current, &result)
+        return result
+    }
+    
+    func findCombination(_ index: Int, _ target: Int, _ candidates: [Int], _ current: inout [Int], _ result: inout [[Int]]) {
+        if target == 0 {
+            result.append(current)
+            return
+        }
+        
+        for i in index..<candidates.count {
+            if candidates[i] <= target {
+                current.append(candidates[i])
+                findCombination(i, target - candidates[i], candidates, &current, &result)
+                current.removeLast()
+            }
+        }
+    }
+}
+ 

combination-sum/hoyeongkwak.py

@@ -0,0 +1,36 @@
+'''
+Time complexity : O(n ^ (target / min_val))
+Space complexity : O(target / min_val)
+backtracking 
+c = [2], total = 2
+c = [2, 2], total = 4
+c = [2, 2, 2] total = 6
+c = [2, 2, 2, 2] total = 8, 초과 backtrack
+c = [2, 2, 2, 3] total = 9, 초과 backtrack
+c = [2, 2, 2, 6] total = 12, 초과 backtrack
+c = [2, 2, 2, 7] total = 13, 초과 backtrack
+c = [2, 2, 3] total = 7 정답 추가
+c = [2, 2, 6] total = 10, 초과 backtrack
+c = [2, 2, 7] total = 11, 초과 backtrack
+....
+[2,2,3], [7]
+
+'''
+
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        result = []
+
+        def backtrack(start, current, total):
+            if total == target:
+                result.append(list(current))
+                return
+            if total > target:
+                return
+            
+            for i in range(start, len(candidates)):
+                current.append(candidates[i])
+                backtrack(i, current, total + candidates[i])
+                current.pop()
+        backtrack(0, [], 0)
+        return result

combination-sum/hu6r1s.py

@@ -0,0 +1,74 @@
+class Solution:
+    """
+    시간 복잡도 (Time Complexity):
+    - 이 문제는 백트래킹(DFS) 기반으로 모든 가능한 조합을 탐색합니다.
+    - 최악의 경우 각 조합에서 한 숫자를 여러 번 사용할 수 있으므로, 트리의 깊이는 최대 target // min(candidates)
+    - 각 깊이마다 최대 len(candidates)만큼 분기 가능
+    - 따라서 시간 복잡도는 지수적으로 증가: O(2^T), T = target
+        (정확한 upper bound는 계산하기 어렵지만, 대략적으로는 O(2^T) 또는 O(k^T)로 볼 수 있음)
+
+    공간 복잡도 (Space Complexity):
+        - 재귀 호출의 최대 깊이: O(T), T = target (가장 작은 숫자만 반복해서 사용하는 경우)
+        - 경로 저장용 리스트(nums): O(T)
+        - 결과 저장용 리스트(output): 최악의 경우 모든 가능한 조합 저장 → O(number of valid combinations * 평균 길이)
+        최종 공간 복잡도: **O(T + R)**,  
+        T: 재귀 깊이 / R: 결과 조합 수가 클 경우 output이 차지하는 공간
+    
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        output, nums = [], []
+
+        def dfs(start, total):
+            if total > target:
+                return
+            if total == target:
+                output.append(nums[:])
+            
+            for i in range(start, len(candidates)):
+                nums.append(candidates[i])
+                dfs(i, total + candidates[i])
+                nums.pop()
+        
+        dfs(0, 0)
+        return output
+    """
+    """
+    2. dp
+    dp[i]는 숫자들을 더해서 합이 i가 되는 모든 조합들을 저장합니다.
+    dp[num - candidate]에 있는 조합에 candidate를 추가하면 num을 만들 수 있으므로 확장합니다.
+    중복된 조합을 방지하기 위해 candidates를 바깥 루프에 둠 (즉, 같은 숫자를 계속 재사용하되, 이전 숫자부터 누적).
+    
+    시간 복잡도 (Time Complexity):
+    바깥 루프: 후보 숫자만큼 → O(N)
+    안쪽 루프: target까지 반복 → O(T)
+    가장 안쪽 루프: dp[num - candidate]에 있는 조합들을 모두 순회 → O(A) (A는 조합 개수 및 길이에 비례)
+    → 따라서 최악의 경우 O(N × T × A)
+
+    공간 복잡도 (Space Complexity):
+    dp 배열 크기: target + 1 → O(T)
+    각 dp[i]에 저장된 조합 리스트들의 개수와 길이 → O(A)
+    따라서 전체 공간은 O(T × A)
+
+    Example 2의 dp 출력:
+
+    [[[]], [], [[2]], [], [], [], [], [], []]
+    [[[]], [], [[2]], [], [[2, 2]], [], [], [], []]
+    [[[]], [], [[2]], [], [[2, 2]], [], [[2, 2, 2]], [], []]
+    [[[]], [], [[2]], [], [[2, 2]], [], [[2, 2, 2]], [], [[2, 2, 2, 2]]]
+    [[[]], [], [[2]], [[3]], [[2, 2]], [], [[2, 2, 2]], [], [[2, 2, 2, 2]]]
+    [[[]], [], [[2]], [[3]], [[2, 2]], [[2, 3]], [[2, 2, 2]], [], [[2, 2, 2, 2]]]
+    [[[]], [], [[2]], [[3]], [[2, 2]], [[2, 3]], [[2, 2, 2], [3, 3]], [], [[2, 2, 2, 2]]]
+    [[[]], [], [[2]], [[3]], [[2, 2]], [[2, 3]], [[2, 2, 2], [3, 3]], [[2, 2, 3]], [[2, 2, 2, 2]]]
+    [[[]], [], [[2]], [[3]], [[2, 2]], [[2, 3]], [[2, 2, 2], [3, 3]], [[2, 2, 3]], [[2, 2, 2, 2], [2, 3, 3]]]
+    [[[]], [], [[2]], [[3]], [[2, 2]], [[2, 3], [5]], [[2, 2, 2], [3, 3]], [[2, 2, 3]], [[2, 2, 2, 2], [2, 3, 3]]]
+    [[[]], [], [[2]], [[3]], [[2, 2]], [[2, 3], [5]], [[2, 2, 2], [3, 3]], [[2, 2, 3], [2, 5]], [[2, 2, 2, 2], [2, 3, 3]]]
+    [[[]], [], [[2]], [[3]], [[2, 2]], [[2, 3], [5]], [[2, 2, 2], [3, 3]], [[2, 2, 3], [2, 5]], [[2, 2, 2, 2], [2, 3, 3], [3, 5]]]
+    """
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        dp = [[] for _ in range(target + 1)]
+        dp[0] = [[]]
+        
+        for candidate in candidates:
+            for num in range(candidate, target + 1):
+                for combination in dp[num - candidate]:
+                    dp[num].append(combination + [candidate])
+        return dp[target]

combination-sum/hyunjung-choi.kt

@@ -0,0 +1,43 @@
+class Solution {
+    fun combinationSum(candidates: IntArray, target: Int): List<List<Int>> {
+        val result = mutableListOf<List<Int>>()
+        val currentCombination = mutableListOf<Int>()
+
+        candidates.sort()
+
+        backtrack(candidates, target, 0, currentCombination, result)
+
+        return result
+    }
+
+    private fun backtrack(
+        candidates: IntArray,
+        remainingTarget: Int,
+        startIndex: Int,
+        currentCombination: MutableList<Int>,
+        result: MutableList<List<Int>>
+    ) {
+        if (remainingTarget == 0) {
+            result.add(currentCombination.toList())
+            return
+        }
+
+        if (remainingTarget < 0) {
+            return
+        }
+
+        for (i in startIndex until candidates.size) {
+            val candidate = candidates[i]
+
+            if (candidate > remainingTarget) {
+                break
+            }
+
+            currentCombination.add(candidate)
+
+            backtrack(candidates, remainingTarget - candidate, i, currentCombination, result)
+
+            currentCombination.removeAt(currentCombination.size - 1)
+        }
+    }
+}

combination-sum/jinvicky.java

@@ -0,0 +1,32 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class Solution {
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        List<List<Integer>> answer = new ArrayList<>();
+
+        makeCombination(candidates, target, 0, new ArrayList<>(), 0, answer);
+        return answer;
+    }
+
+    private void makeCombination(int[] candidates,
+                                 int target,
+                                 int idx,
+                                 List<Integer> comb,
+                                 int total,
+                                 List<List<Integer>> res) {
+        if (total == target) {
+            res.add(new ArrayList<>(comb));
+            return;
+        }
+
+        if (total > target || idx >= candidates.length) {
+            return;
+        }
+
+        comb.add(candidates[idx]);
+        makeCombination(candidates, target, idx, comb, total + candidates[idx], res);
+        comb.remove(comb.size() - 1);
+        makeCombination(candidates, target, idx + 1, comb, total, res);
+    }
+}

combination-sum/mkwkw.cpp

@@ -0,0 +1 @@
+//set-up

combination-sum/ohgyulim.java

@@ -0,0 +1,25 @@
+import java.util.*;
+
+class Solution {
+    List<List<Integer>> answer = new ArrayList<>();
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        Arrays.sort(candidates);
+        recur(new ArrayList<Integer>(), candidates, target, 0, 0);
+        return answer;
+    }
+
+    public void recur(List<Integer> result, int[] candidates, int target, int sum, int index) {
+        if (sum == target) {
+            List<Integer> deepCopyRes = new ArrayList<>(result);
+            answer.add(deepCopyRes);
+            return;
+        }
+        for (int i = index; i < candidates.length; i++) {
+            if (sum + candidates[i] <= target) {
+                result.add(candidates[i]);
+                recur(result, candidates, target, sum + candidates[i], i);
+                result.remove(Integer.valueOf(candidates[i]));
+            }
+        }
+    }
+}

decode-ways/delight010.swift

@@ -0,0 +1,19 @@
+class Solution {
+    func numDecodings(_ s: String) -> Int {
+        var array = Array(s)
+        var dp: [Int: Int] = [array.count: 1]
+        for i in stride(from: array.count - 1, to: -1, by: -1) {
+            if array[i] == "0" {
+                dp[i] = 0
+            } else {
+                dp[i] = dp[i + 1]
+            }
+
+            if i + 1 < array.count && (array[i] == "1" || array[i] == "2" && "0123456".contains(array[i + 1])) {
+                dp[i, default: 0] += dp[i + 2] ?? 0
+            }
+        }
+        return dp[0]!
+    }
+}
+