Merge branch 'DaleStudy:main' into main

Author: chordpli

3sum/devyejin.py

@@ -0,0 +1,36 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort() # O(n)
+
+        n = len(nums)
+        result = []
+
+        for i in range(n - 2):
+            # target을 잡을때도 이전에 구했다면 패스
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            target = - nums[i]
+            left, right = i + 1, n - 1
+
+            while left < right:
+                two_sum = nums[left] + nums[right]
+
+                if two_sum == target:
+                    result.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 two_sum < target:
+                    left += 1
+                else:
+                    right -= 1
+
+        return result

climbing-stairs/devyejin.py

@@ -0,0 +1,17 @@
+class Solution(object):
+    def climbStairs(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+        if n <= 2:
+            return n
+
+        dp = [0] * (n + 1)
+        dp[1], dp[2] = 1, 2
+
+        for i in range(3, n + 1):
+            dp[i] = dp[i-1] + dp[i-2]
+
+        return dp[n]
+

coin-change/hyer0705.ts

@@ -0,0 +1,17 @@
+function coinChange(coins: number[], amount: number): number {
+  // dp[i] = i 금액을 만드는 데 필요한 최소 동전의 갯수...
+  const dp: number[] = Array(amount + 1).fill(Infinity);
+  dp[0] = 0;
+
+  for (let i = 1; i <= amount; i++) {
+    let min = Infinity;
+    for (const coin of coins) {
+      if (i >= coin) {
+        min = Math.min(dp[i - coin] + 1, min);
+      }
+    }
+    dp[i] = min;
+  }
+
+  return Number.isFinite(dp[amount]) ? dp[amount] : -1;
+}

coin-change/hyunjung-choi.kt

@@ -0,0 +1,21 @@
+/**
+ * 시간복잡도: O(amount × coins.length)
+ * 공간복잡도: O(amount)
+ */
+
+class Solution {
+    fun coinChange(coins: IntArray, amount: Int): Int {
+        val dp = IntArray(amount + 1) { Int.MAX_VALUE }
+        dp[0] = 0
+
+        for (i in 1..amount) {
+            for (coin in coins) {
+                if (i - coin >= 0 && dp[i - coin] != Int.MAX_VALUE) {
+                    dp[i] = minOf(dp[i], dp[i - coin] + 1)
+                }
+            }
+        }
+
+        return if (dp[amount] == Int.MAX_VALUE) -1 else dp[amount]
+    }
+}

combination-sum/devyejin.py

@@ -0,0 +1,20 @@
+class Solution:
+    def combinationSum(self, candidates: list[int], target: int) -> list[list[int]]:
+
+        def backtracking(start, total, result):
+            if total == target:
+                answer.append(result[:])
+                return
+
+            if sum(result) > target:
+                return
+
+            for i in range(start, len(candidates)):
+                result.append(candidates[i])
+                backtracking(i, total + candidates[i], result)
+                result.pop()
+
+        answer = []
+        backtracking(0, 0, [])
+        return answer
+

combination-sum/grapefruitgreentealoe.js

@@ -0,0 +1,93 @@
+/**
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+
+/**
+ * candidates를 여러번 사용해도 된다. 하지만 사용한 종류와 개수가 모두 같으면 안된다. 
+ * 
+ */
+var combinationSum = function(candidates, target) {
+    const candidatesLength = candidates.length
+    // 시작 시점에서 array를 만들어서 넘겨줘야한다. 
+    // candidates 중에 넣으면 target이 되면 답에 그 배열을 넣고 탈출한다. 
+    // 만약 더했는데 target보다 크면 그냥 리턴한다. 
+    // target보다 작은것에 대해서 넣는다.
+    const ret = []
+    function dp(total,newNum,currentArr){
+        if(total + newNum > target){
+            return
+        }
+        if(total + newNum == target && ){
+            ret.push([...currentArr,newNum]);
+            return
+        }
+
+        //두 가지 어느것에도 해당하지 않으면 재귀를 또 다시 돈다.
+        for(let i = 0; i<candidatesLength; i++){
+            dp(total+newNum , candidates[i],[...currentArr,candidates[i]])
+        }
+    }
+    dp(0,0,[])
+    return ret
+};
+
+//여기서 문제가 생겼다. 
+// 중복이 생긴다는 것이다. 어떻게 중복을 제거하면 좋을까?
+/**
+ * 1. Set을 이용한다.
+ * 2. 순서를 둔다. idx를 dfs에 넘겨주어서, 순서대로 작동하게 한다. 
+ */
+
+var combinationSum = function(candidates, target) {
+    const candidatesLength = candidates.length
+    const ret = []
+    function dp(idx,total,currentArr){
+        if(total > target){
+            return
+        }
+        if(total == target){
+            ret.push(currentArr);
+            return
+        }
+
+        //idx를 넘겨받아서, 그 이후의 것에만(자기 자신 포함) 돌게 된다. 그러면 절반정도만 돈다고 볼 수 있다.
+        for(let i = idx; i < candidatesLength; i++){
+            dp(i,total+ candidates[i],[...currentArr,candidates[i]])
+        }
+    }
+    dp(0,0,[])
+    return ret
+};
+
+
+
+/**
+ 시간복잡도: O(N^(target/min)) : N개 후보 중 선택하는 경우의 수가 target/min 깊이만큼 반복
+공간복잡도: O(target/min) : 재귀 스택의 최대 깊이가 target/min
+
+
+ */
+
+
+// 2. dp를 활용한 문제 해결방법
+var combinationSum = function(candidates, target) {
+    const dp = Array.from({length:target+1},()=>[])
+    dp[0] = [[]];
+    for(let candidate of candidates){
+        //여기서 candidate에 대해서, 이후 타겟까지 더할 수있는 숫자에 대한 조합에, candidate를 각각 넣어준다.
+        for(let i = candidate; i <= target; i++){
+            for(let comb of dp[i-candidate]){ //각 조합에 넣어줌
+                dp[i].push([...comb,candidate])
+            }   
+        }
+    }
+    return dp[target]
+};
+/**
+시간복잡도: O(N × target × M)
+N개 후보를 순회하면서, 각 후보마다 target까지의 값들에 대해 기존 조합들을 복사해서 새 조합을 생성하는데, 기존의 조합의 수 M을 곱해야함
+공간복잡도: O(target × M)
+dp 배열의 각 인덱스에 해당 값을 만드는 모든 조합들을 저장. 조합개수에 따라서 커짐
+ */

combination-sum/hyer0705.ts

@@ -0,0 +1,21 @@
+function combinationSum(candidates: number[], target: number): number[][] {
+  const results: number[][] = [];
+
+  function backtrack(currentIndex: number, sum: number, selected: number[]) {
+    if (sum > target) return;
+    if (sum === target) {
+      results.push([...selected]);
+      return;
+    }
+
+    for (let i = currentIndex; i < candidates.length; i++) {
+      selected.push(candidates[i]);
+      backtrack(i, sum + candidates[i], selected);
+      selected.pop();
+    }
+  }
+
+  backtrack(0, 0, []);
+
+  return results;
+}

combination-sum/jongwanra.py

@@ -0,0 +1,100 @@
+"""
+[Problem]
+https://leetcode.com/problems/combination-sum/
+
+candidates: unique array of integers
+return a list of all unique combinations of candidates == target
+any order
+
+하나의 숫자는 candidates에서 무제한으로 선택할 수 있다.
+두 조합이 서로 다르다고 간주되는 조건은, 선택된 숫자 중 적어도 하나의 개수가 다를 때이다.
+[Brainstorming]
+DFS를 이용해서 Combination을 만든다.
+종료조건: target == sum || target > sum
+
+[Plan]
+1. candidates를 오름차순 정렬
+2. DFS
+
+[Complexity]
+N -> candidates.length
+M -> approximately target divided by the smallest candidate. -> target / min(candidates)
+Time: O(N^M)
+Space: O(N + M)
+  - 재귀 호출 스택: 깊이는 최대 target / min(candidates)
+  - chosen: 재귀 스택 깊이 만큼 공간 차지
+  - cache: 최악의 경우 answer와 같은 개수의 조합 저장 -> O(number of combinations)
+"""
+
+from typing import List
+
+
+class Solution:
+    def combinationSum1(self, candidates: List[int], target: int) -> List[List[int]]:
+        cache = set()
+        answer = []
+        chosen = []
+
+        def dfs(sum: int) -> None:
+            nonlocal target, candidates, cache, answer, chosen
+            print(chosen)
+            if sum > target:
+                return
+            if sum == target:
+                copied_chosen = chosen[:]
+                copied_chosen.sort()
+
+                cache_key = tuple(copied_chosen)
+                if cache_key in cache:
+                    # print(f"already exists {cache_key} in cache")
+                    return
+                cache.add(cache_key)
+                answer.append(copied_chosen)
+
+            for candidate in candidates:
+                chosen.append(candidate)
+                dfs(sum + candidate)
+                chosen.pop()
+
+        dfs(0)
+        return answer
+
+    """
+    중복 조합 방지 another solution
+    ref: https://www.algodale.com/problems/combination-sum/
+
+    [Complexity]
+    N -> candidates.length
+    M -> target / min(candidates)
+    Time: O(N^M)
+    Space: O(M)
+    """
+
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        answer = []
+        combi = []
+
+        def dfs(sum: int, start: int) -> None:
+            nonlocal target, answer, combi, candidates
+
+            if sum > target:
+                return
+            if sum == target:
+                answer.append(combi[:])
+                return
+
+            for index in range(start, len(candidates)):
+                candidate = candidates[index]
+                combi.append(candidate)
+                dfs(sum + candidate, index)
+                combi.pop()
+
+        dfs(0, 0)
+        return answer
+
+
+sol = Solution()
+# print(sol.combinationSum([2,3,6,7], 7))
+print(sol.combinationSum([2, 3, 5], 8))
+# print(sol.combinationSum([2], 1))
+

combination-sum/jun0811.js

@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+var combinationSum = function (candidates, target) {
+  const result = [];
+  candidates.sort((a, b) => a - b);
+  function backTracking(start, arr, total) {
+    if (total == target) {
+      result.push([...arr]);
+      return;
+    }
+
+    for (let i = start; i < candidates.length; i++) {
+      const cur = candidates[i];
+      if (cur + total > target) {
+        return;
+      }
+
+      backTracking(i, [...arr, cur], total + cur);
+    }
+  }
+
+  backTracking(0, [], 0);
+  return result;
+};

combination-sum/prograsshopper.py

@@ -0,0 +1,17 @@
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        # Time complexity: O(n ^ (T / m))
+        result = []
+
+        def dfs(remain_sum, index, path):
+            if remain_sum < 0:
+                return
+            if remain_sum == 0:
+                result.append(path)
+                return
+
+            for i in range(index, len(candidates)):
+                dfs(remain_sum - candidates[i], i, path + [candidates[i]])
+
+        dfs(target, 0, [])
+        return result