Merge branch 'main' of https://github.com/YuuuuuuYu/leetcode-study

Author: YuuuuuuYu

climbing-stairs/hongseoupyun.py

@@ -20,7 +20,7 @@ def climbStairs(self, n: int) -> int:
 
         prev1 = 1
         prev2 = 2
-        for i in range(n,n+1):
+        for i in range(3,n+1):
             current = prev2 + prev1
             prev1 = prev2
             prev2 = current

climbing-stairs/ymir0804.java

@@ -0,0 +1,22 @@
+class Solution {
+    public int climbStairs(int n) {
+        int result = 0;
+        int first = 1;
+        int second = 2;
+        int third = 3;
+        if (n == 1) {
+            return first;
+        } else if (n == 2) {
+            return second;
+        } else if (n == 3) {
+            return third;
+        }
+
+        for (int i = 4; i <= n; i++) {
+            result = second + third;
+            second = third;
+            third = result;
+        }
+        return result;
+    }
+}

climbing-stairs/youngDaLee.go

@@ -0,0 +1,34 @@
+package youngDaLee
+
+func climbStairs(n int) int {
+	if n <= 2 {
+		return n
+	}
+
+	dp := make([]int, n+1)
+	dp[1] = 1
+	dp[2] = 2
+
+	for i := 3; i <= n; i++ {
+		dp[i] = dp[i-1] + dp[i-2]
+	}
+	return dp[n]
+}
+
+/*
+Limit Exceeded
+func climbStairs(n int) int {
+	return dfs(0, n)
+}
+
+func dfs(now, n int) int {
+	if now > n {
+		return 0
+	}
+	if now == n {
+		return 1
+	}
+
+	return dfs(now+1, n) + dfs(now+2, n)
+}
+*/

combination-sum/1lsang.ts

@@ -0,0 +1,16 @@
+function combinationSum(candidates: number[], target: number): number[][] {
+  // arr: index까지 갈 수 있는 combinationSum
+  const arr:number[][][] = Array.from({ length: target + 1 }, () => [] as number[][]); 
+  // 0을 만들 수 있는 방법은 숫자가 없는 것
+  arr[0].push([] as number[]);
+  
+  for (const candidate of candidates) {
+    for (let n = candidate; n <= target; n++) {
+      for (const combination of arr[n-candidate]) {
+        arr[n].push([...combination, candidate]);
+      }
+    }
+  }
+  console.log(arr);
+  return arr[target];
+};

combination-sum/Blossssom.ts

@@ -0,0 +1,36 @@
+/**
+ * @param - candidates: 정수 배열, target: 대상 정수
+ * @returns - 선택한 숫자의 합이 해당하는 모든 고유 조합 반환
+ * @description
+ * 1. 요소는 여러번 사용 가능
+ */
+
+function combinationSum(candidates: number[], target: number): number[][] {
+  const result: number[][] = [];
+
+  function recursive(remain: number, idx: number, path: number[]) {
+    if (remain === 0) {
+      result.push([...path]);
+      return;
+    }
+
+    for (let i = idx; i < candidates.length; i++) {
+      const currentNum = candidates[i];
+      if (currentNum > remain) {
+        break;
+      }
+
+      path.push(currentNum);
+      recursive(remain - currentNum, i, path);
+      path.pop();
+    }
+  }
+
+  recursive(target, 0, []);
+  return result;
+}
+
+const candidates = [2, 3, 5];
+const target = 8;
+combinationSum(candidates, target);
+

combination-sum/Donghae0230.py

@@ -0,0 +1,21 @@
+# 문제 풀이
+# 모든 경우의 수를 탐색하기 위해 백트래킹 사용
+# - 현재 조합의 합이 target보다 크면 종료
+# - 현재 조합의 합이 target과 같으면 결과에 추가
+
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        def backtrack(start, combination):
+            if sum(combination) > target:
+                return
+            if sum(combination) == target:
+                result.append(combination[:]) 
+                return 
+            for i in range(start, len(candidates)):
+                combination.append(candidates[i])
+                backtrack(i, combination)
+                combination.pop()
+            
+        result = []
+        backtrack(0, [])
+        return result

combination-sum/JangAyeon.js

@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+var combinationSum = function (arr, target) {
+  const N = arr.length;
+  const answer = [];
+  function dfs(total, idx, route) {
+    if (total >= target) {
+      if (total == target) {
+        answer.push(route);
+      }
+      return;
+    }
+    for (let i = idx; i < N; i++) {
+      dfs(total + arr[i], i, [...route, arr[i]]);
+    }
+  }
+
+  dfs(0, 0, []);
+  return answer;
+};

combination-sum/Seoya0512.py

@@ -0,0 +1,15 @@
+'''
+Approach
+- target값에서 candidate 값을 빼고 그 누적합을 사용해야한다는 흐름은 파악했지지만 구현이 어려웠습니다.
+-그래서 알고달레를 참고해서 최대한 이해하고 혼자 작성해보려고 했습니다....
+'''
+class Solution:
+    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/casentino.ts

@@ -0,0 +1,20 @@
+function combinationSum(candidates: number[], target: number): number[][] {
+  const results: number[][] = [];
+
+  function comb(index: number, arr: number[], sum: number) {
+    if (sum === target) {
+      results.push([...arr]);
+      return;
+    }
+    if (sum > target || candidates.length <= index) {
+      return;
+    }
+    arr.push(candidates[index]);
+    comb(index, arr, sum + candidates[index]);
+    arr.pop();
+    comb(index + 1, arr, sum);
+  }
+
+  comb(0, [], 0);
+  return results;
+}

combination-sum/changhyumm.py

@@ -0,0 +1,19 @@
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        ans = []
+        def combination(index, cur_comb, cur_sum):
+            if cur_sum == target:
+                ans.append(cur_comb[:])
+                return
+            if cur_sum > target or index >= len(candidates):
+                return
+            cur_comb.append(candidates[index])
+            combination(index, cur_comb, cur_sum + candidates[index])
+            # 합이 target이랑 같던지, 크던지, 길이를 넘던지하면 return으로 탈출
+            # 그 외에 다른 경우의 수를 봐야하므로 
+            # 마지막꺼는 다시 빼고 어쨌든 index 넘겨서 다시 combination 확인해봐야함
+            cur_comb.pop()
+            combination(index + 1, cur_comb, cur_sum)
+            return ans
+            
+        return combination(0, [], 0)