Merge branch 'DaleStudy:main' into main

Author: gitsunmin

climbing-stairs/haklee.py

@@ -0,0 +1,26 @@
+"""TC: O(n), SC: O(1)
+
+아이디어: 
+계단의 k번째 칸까지 도달하는 방법의 수를 f(k)라고 하자.
+f(k)는 다음의 두 경우의 수를 더한 값이다.
+  - k-2번째 칸까지 간 다음 두 칸 뜀. 즉, f(k-2)
+  - k-1번째 칸까지 간 다음 두 칸 뜀. 즉, f(k-1)
+즉, f(k) = f(k-2) + f(k-1)
+
+
+SC:
+- tabulation 과정에서 값 2개만 계속 유지한다.
+- 즉, O(1).
+
+TC:
+- 단순 덧셈 계산(O(1))을 O(n)번 반복한다.
+- 즉, O(n).
+"""
+
+
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        a, b = 1, 1
+        for _ in range(n - 1):
+            a, b = b, a + b
+        return b

climbing-stairs/highball.js

@@ -0,0 +1,11 @@
+const climbStairs = function (n) {
+  const dp = [1, 1];
+
+  for (let i = 0; i < n - 1; i++) {
+    const temp = dp[1];
+    dp[1] = temp + dp[0];
+    dp[0] = temp;
+  }
+
+  return dp[1];
+};

climbing-stairs/hwanmini.js

@@ -0,0 +1,18 @@
+// 시간복잡도 O(n)
+// 공간복잡도 O(n)
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function(n) {
+    const stairs = [1, 2]
+
+    for (let i = 2; i < n; i++) {
+        stairs[i] = stairs[i-1] + stairs[i-2]
+    }
+
+    return stairs[n-1]
+};
+
+console.log(climbStairs(5))

climbing-stairs/hyejjun.js

@@ -0,0 +1,28 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function (n) {
+  if (n <= 2) return n;
+
+  let first = 1;
+  let second = 2;
+
+  for (let i = 3; i <= n; i++) {
+    let third = first + second;
+    first = second;
+    second = third;
+  }
+
+  return second;
+};
+
+console.log(climbStairs(2));
+console.log(climbStairs(3));
+console.log(climbStairs(4));
+console.log(climbStairs(5));
+
+/*
+시간 복잡도: O(n)
+공간 복잡도: O(1)
+*/

climbing-stairs/jaejeong1.java

@@ -0,0 +1,29 @@
+class SolutionClimbStairs {
+
+  public int climbStairs(int n) {
+    // n번째 계단까지 오르는 방법의 수
+    // 첫 번째 계단까지 오르는 방법은 1가지
+    // 두 번째 계단까지 오르는 방법은 2가지
+    // 세 번째 계단부터는 이전 두 계단의 방법을 더하여 계산
+    // stairs[i]는 i번째 계단까지 오르는 방법의 수
+    // 시간복잡도: O(N), 공간복잡도: O(N)
+    if (n == 1) {
+      return 1;
+    }
+
+    if (n == 2) {
+      return 2;
+    }
+
+    int[] stairs = new int[n+1];
+    stairs[1] = 1;
+    stairs[2] = 2;
+
+
+    for (int i=3; i<=n; i++) {
+      stairs[i] = stairs[i-1] + stairs[i-2];
+    }
+
+    return stairs[n];
+  }
+}

climbing-stairs/kayden.py

@@ -0,0 +1,12 @@
+# 시간복잡도: O(N)
+# 공간복잡도: O(N)
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        dp = [0] * (n + 1)
+        dp[0] = 1
+        dp[1] = 1
+
+        for i in range(2, n + 1):
+            dp[i] = dp[i - 1] + dp[i - 2]
+
+        return dp[n]

climbing-stairs/seona926.js

@@ -0,0 +1,24 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+let climbStairs = function (n) {
+  if (n <= 1) return 1;
+
+  let ways = new Array(n + 1);
+  ways[0] = 1;
+  ways[1] = 1;
+
+  for (let i = 2; i <= n; i++) {
+    ways[i] = ways[i - 1] + ways[i - 2]; // 점화식 사용
+  }
+
+  return ways[n];
+};
+
+/*
+  1. 시간 복잡도: O(n)
+    - for 루프의 시간 복잡도
+  2. 공간 복잡도: O(n)
+    - 배열 ways의 공간 복잡도
+*/

climbing-stairs/whewchews.ts

@@ -0,0 +1,56 @@
+/*
+    * 아이디어 
+    * 층수 제한: 1 <= n <= 45
+    * 1 or 2 step 만 올라갈 수 있음
+    
+    * 1 -> [1]
+    * 2 -> [1,1]              [2]                                     
+    * 3 -> [1,1,1]            [2,1] [1,2]                             
+    * 4 -> [1,1,1,1]          [2,1,1] [1,2,1] [1,1,2]                            [2,2]     
+    * 5 -> [1,1,1,1,1]        [2,1,1,1] [1,2,1,1] [1,1,2,1] [1,1,1,2]      [2,2,1], [1,2,2], [2,1,2]
+    * 6 -> [1,1,1,1,1,1]      [2,1,1,1,1] [...] [1,1,1,1,2]                     [2,2,1,1], [2,1,2,1], [2,1,1,2] [1,1,2,2], [1,2,1,2], [1,2,2,1]
+    =>     (1:n, 2:0) n가지   (1:n-2, 2:1) / n가지                         (1: n-4, 2: n/2) C(n, n/2) 가지   
+    */
+function climbStairs(n: number): number {
+  // # Solution 1
+
+  // const stair = {1: 1, 2:2}
+  // for(let i = 3; i<=n; i++){
+  //     stair[i] = stair[i-1] + stair[i-2]
+  // }
+  // TC: O(N)
+  // SC: O(N)
+
+  // # Solution 2
+
+  //     if(n < 3) return n
+  //     let curr = 2 // 현재 계단을 오르는 방법 수
+  //     let prev = 1 // 이전 계단을 오르는 방법 수
+
+  //     for(let i=0; i<n-2; i++){
+  //         const next = prev + curr;
+  //         prev = curr;
+  //         curr = next;
+  //     }
+
+  //     return curr
+  // TC: O(N)
+  // SC: O(1)
+
+  // # Solution 3: 재귀
+  const memo = { 1: 1, 2: 2 };
+  function calculateClimbingWay(n, memo) {
+    if (n in memo) return memo[n];
+
+    if (n < 3) {
+      return n;
+    }
+    memo[n] =
+      calculateClimbingWay(n - 1, memo) + calculateClimbingWay(n - 2, memo);
+
+    return memo[n];
+  }
+  return calculateClimbingWay(n, memo);
+  // TC: O(N)
+  // SC: O(N)
+}

climbing-stairs/wogha95.js

@@ -0,0 +1,21 @@
+// DP 활용하였고 메모리 축소를 위해 현재와 직전의 경우의 수만 관리하였습니다.
+// TC: O(N)
+// SC: O(1)
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function (n) {
+  let previousStep = 0;
+  let currentStep = 1;
+
+  while (n > 0) {
+    n -= 1;
+    const nextStep = previousStep + currentStep;
+    previousStep = currentStep;
+    currentStep = nextStep;
+  }
+
+  return currentStep;
+};

coin-change/haklee.py

@@ -0,0 +1,51 @@
+"""TC: O(m*n), SC: O(n)
+
+coin 종류: m
+amount 크기: n
+
+아이디어: 
+값 k를 만들때 필요한 최소 동전의 수를 f(k)라고 하자.
+f(k)는 다음의 경우 중 제일 작은 값이다.
+  - 동전 c1을 마지막으로 더해서 k를 만들었다. f(k-c1) + 1개의 동전 필요.
+  - 동전 c2을 마지막으로 더해서 k를 만들었다. f(k-c2) + 1개의 동전 필요.
+  - ...
+  - 동전 cm을 마지막으로 더해서 k를 만들었다. f(k-cm) + 1개의 동전 필요.
+즉, f(k) = min(f(k-c1), f(k-c2), ..., f(k-cm)) + 1
+
+이때, n보다 작은 모든 i에 대해서 한 번 f(i)값을 계산할 일이 있었으면 이를 저장해두고 사용하는 방법으로
+접근해서 문제를 풀 수 있다.
+
+SC:
+- n보다 작은 모든 i에 대해 f(i)값을 저장해두는 배열 필요.
+- 즉, O(n).
+
+TC:
+- 각 f(i)마다 최초 계산시 m개의 아이템을 list에 넣고 min값을 찾는 계산을 한 번 한다. O(m).
+- 최초 계산이 아닐 경우 배열에 저장된 값을 가져온다. O(1).
+- 각 f(i)는 f(i+c1), f(i+c2), ..., f(i+cm)을 계산할때 호출되는데, 여기에 O(m) + O(1) + ... + O(1)
+  만큼의 시간이 소요되므로 종합하면 O(m) + (m+1)*O(1) = O(m) 만큼의 시간이 소요된다.
+- 이러한 f(i)값이 총 n개 있다. 즉, O(m*n).
+"""
+
+
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        arr = [None for _ in range(amount + 1)]  # None값은 아직 계산되지 않았다는 뜻.
+        arr[0] = 0  # 초기화
+
+        def dp(target):
+            if arr[target] is None:  # 만약 아직 f(target)이 계산되지 않았다면
+                # 모든 동전들 c에 대해 f(target - c)는 다음의 경우들만 유효하다.
+                # - target이 동전 c의 크기 이상은 되어야 한다.
+                # - 앞서 계산해본 결과 총 금액 target - c를 구할 수 없는 경우는 무시.
+                #    - 구할 수 없는 것으로 판명된 경우 f(x)의 값이 -1이다.
+                candidates = [
+                    v for c in coins if target - c >= 0 and (v := dp(target - c)) >= 0
+                ]
+                # candidates에 유효한 f(target - c)값이 하나도 없으면 f(target)은 -1이다.
+                # 그게 아니라면 candidates에 들어있는 값 중 제일 적은 수의 동전을 필요로 하는
+                # 경우에 1을 더한 값을 f(target)에 넣어둠.
+                arr[target] = -1 if len(candidates) == 0 else min(candidates) + 1
+            return arr[target]
+
+        return dp(amount)