Merge remote-tracking branch 'upstream/main'

merge to latest head

Author: sun912

climbing-stairs/HC-kang.ts

@@ -0,0 +1,11 @@
+// T.C. O(n)
+// S.C. O(1)
+function climbStairs(n: number): number {
+  let p = 0;
+  let q = 1;
+  for (let i = 0; i < n; i++) {
+    q = q + p;
+    p = q - p;
+  }
+  return q;
+}

climbing-stairs/TonyKim9401.java

@@ -0,0 +1,15 @@
+class Solution {
+    public int climbStairs(int n) {
+        // Time complexity: O(n);
+        // Space complexity: O(n);
+        int[] dp = new int[n+1];
+
+        if (n >= 1) dp[1] = 1;
+        if (n >= 2) dp[2] = 2;
+
+        for (int i = 3; i <= n; i++) {
+            dp[i] = dp[i-1] + dp[i-2];
+        }
+        return dp[n];
+    }
+}

climbing-stairs/bemelon.py

@@ -0,0 +1,17 @@
+class Solution:
+    # Space complexity: O(1)
+    # Tiem complexity: O(n)
+    def climbStairs(self, n: int) -> int:
+        # dp[0] is n - 2
+        # dp[1] is n - 1
+        dp = [1, 2]
+
+        if n <= 2: 
+            return dp[n - 1]
+        
+        for i in range(3, n + 1): 
+            # dp[n] = dp[n - 1] + dp[n - 2]
+            #       = dp[1] + dp[0]
+            dp[(i - 1) % 2] = sum(dp)
+        
+        return dp[(n - 1) % 2]

climbing-stairs/flynn.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+int climbStairs(int n) {
+vector<int> memo(2, 1);
+
+        for (int i = 2; i <= n; i++) {
+            memo.push_back(memo[i - 1] + memo[i - 2]);
+        }
+
+        return memo[n];
+    }
+
+};

climbing-stairs/gitsunmin.ts

@@ -0,0 +1,17 @@
+/**
+ * https://leetcode.com/problems/climbing-stairs
+ * time complexity : O(n)
+ * space complexity : O(1)
+ */
+
+export const upStairs = (n: number): number => {
+    let [l, r] = [1, 2];
+    for (let i = 3; i <= n; i++) [l, r] = [r, l + r];
+
+    return r;
+};
+
+export function climbStairs(n: number): number {
+    if (n <= 2) return n;
+    return upStairs(n);
+};

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/heozeop.cpp

@@ -0,0 +1,20 @@
+// Time Complexity: O(n)
+// Spatial Complexity: O(n)
+
+class Solution {
+public:
+  int climbStairs(int n) {
+    vector<int> dp(n + 1, 0);
+
+    if (n == 1) {
+        return 1;
+    }
+
+    dp[0] = dp[1] = 1;
+    for(int i = 2; i <= n; ++i) {
+        dp[i] = dp[i - 1] + dp[i - 2];
+    }
+
+    return dp[n];
+  }
+};

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)
+*/