Add recursive staircase

Author: Ren0503

src/algorithms/others/recursive-staircase/README.md

@@ -0,0 +1,21 @@
+# Bài Toán Đệ Quy Cầu Thang
+
+## Vấn đề
+
+Có `n` bậc thang, người đứng dưới cầu thang muốn đi lên trên cùng. Họ có thể lựa chọn bước `1` hoặc `2` bậc tại một thời điểm. _Đếm số cách mà một người có thể đi lên trên cầu thang_.
+
+![](https://cdncontribute.geeksforgeeks.org/wp-content/uploads/nth-stair.png)
+
+## Giải pháp
+
+Đây là một bài toán thú vị vì có nhiều cách để giải nó, dưới đây là minh hoạ của các giải pháp lập trình khác nhau.
+
+- [Phá Mã](./recursiveStaircaseBF.js) - Thời gian: `O(2^n)`; Không gian: `O(1)`
+- [Dùng Bộ Nhớ Phụ](./recursiveStaircaseMEM.js) - Thời gian: `O(n)`; Không gian: `O(n)`
+- [Quy Hoạch Động](./recursiveStaircaseDP.js) - Thời gian: `O(n)`; Không gian: `O(n)`
+- [Vòng Lặp](./recursiveStaircaseIT.js) - Time: `O(n)`; Space: `O(1)` 
+
+## Vòng Lặp
+
+- [On YouTube by Gayle Laakmann McDowell](https://www.youtube.com/watch?v=eREiwuvzaUM&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8&index=81&t=0s)
+- [GeeksForGeeks](https://www.geeksforgeeks.org/count-ways-reach-nth-stair/)

src/algorithms/others/recursive-staircase/recursiveStaircaseBF.js

@@ -0,0 +1,26 @@
+/**
+ * Bài Toán Đệ Quy Cầu Thang (Phá Mã)
+ *
+ * @param {number} stairsNum - số bậc có thể bước.
+ * @return {number} - Số cách để bước lên cầu thang.
+ */
+export default function recursiveStaircaseBF(stairsNum) {
+    if (stairsNum <= 0) {
+        // Số bậc nhỏ hơn 1 thì không có gì để bước
+        return 0;
+    }
+
+    if (stairsNum === 1) {
+        // Nếu chỉ có 1 bậc chỉ có một cách bước.
+        return 1;
+    }
+
+    if (stairsNum === 2) {
+        // Nếu có hai bậc có hai cách bước là (1+1) và (2).
+        return 2;
+    }
+
+    // Tính tổng số bước ta cần thực hiện sau khi thực hiện một bước 
+    // với số bước ta cần thực hiện sau khi thực hiện hai bước lên.
+    return recursiveStaircaseBF(stairsNum - 1) + recursiveStaircaseBF(stairsNum - 2);
+}

src/algorithms/others/recursive-staircase/recursiveStaircaseDP.js

@@ -0,0 +1,33 @@
+/**
+ * Bài Toán Đệ Quy Cầu Thang (Quy Hoạch Động)
+ *
+ * @param {number} stairsNum - số bậc có thể bước.
+ * @return {number} - Số cách để bước lên cầu thang.
+ */
+export default function recursiveStaircaseDP(stairsNum) {
+    if (stairsNum < 0) {
+        // Không có bậc thang nào để bước.
+        return 0;
+    }
+
+    // Khởi tạo vector "steps" sẽ chứa tất cả các cách có thể đến bước tương ứng.
+    const steps = new Array(stairsNum + 1).fill(0);
+
+    // Khởi tạo số cách để đến bậc thứ 0, 1 và 2.
+    steps[0] = 0;
+    steps[1] = 1;
+    steps[2] = 2;
+
+    if (stairsNum <= 2) {
+        // Trả về số cách để đến bậc thứ 0, 1 và 2.
+        return steps[stairsNum];
+    }
+
+    // Tính toán bước kế tiếp dựa trên hai bước trước nó.
+    for (let currentStep = 3; currentStep <= stairsNum; currentStep += 1) {
+        steps[currentStep] = steps[currentStep - 1] + steps[currentStep - 2];
+    }
+
+    // Trả về các cách để có thể đi hết cầu thang.
+    return steps[stairsNum];
+}

src/algorithms/others/recursive-staircase/recursiveStaircaseIT.js

@@ -0,0 +1,30 @@
+/**
+ * Bài Toán Đệ Quy Cầu Thang (Vòng Lặp)
+ *
+ * @param {number} totalStairs - số bậc có thể bước.
+ * @return {number} - Số cách để bước lên cầu thang.
+ */
+export default function recursiveStaircaseIT(stairsNum) {
+    if (stairsNum <= 0) {
+        // Số bậc nhỏ hơn 1 thì không có gì để bước
+        return 0;
+    }
+
+    // Tạo mảng lưu số cách đến bậc thứ 0, 1 và 2.
+    const steps = [1, 2];
+
+    if (stairsNum <= 2) {
+        // Trả về số cách có thể để đến bậc thứ 1 hoặc thứ 2.
+        return steps[stairsNum - 1];
+    }
+
+    // Tính số cách đi đến bước thứ n dựa trên những cách trước đó.
+    // So với giải pháp Quy hoạch động, ta chỉ  lưu trữ thông tin cho hai bước 
+    // trước nó thay vì lưu tất cả các bước.
+    for (let currentStep = 3; currentStep <= stairsNum; currentStep += 1) {
+        [steps[0], steps[1]] = [steps[1], steps[0] + steps[1]];
+    }
+
+    // Trả lại các cách có thể để đến bậc được yêu cầu.
+    return steps[1];
+}

src/algorithms/others/recursive-staircase/recursiveStaircaseMEM.js

@@ -0,0 +1,43 @@
+/**
+ * Bài Toán Đệ Quy Cầu Thang (Giải Pháp dùng Bộ Nhớ Phụ)
+ *
+ * @param {number} totalStairs - số bậc có thể bước.
+ * @return {number} - Số cách để bước lên cầu thang.
+ */
+export default function recursiveStaircaseMEM(totalStairs) {
+    // Bảng ghi nhớ sẽ chứa tất cả các kết quả được tính toán đệ quy để 
+    // tránh tính toán chúng nhiều lần.
+    const memo = [];
+
+    // Đệ quy với closure.
+    const getSteps = (stairsNum) => {
+        if (stairsNum <= 0) {
+            // Số bậc nhỏ hơn 1 thì không có gì để bước
+            return 0;
+        }
+
+        if (stairsNum === 1) {
+            // Nếu chỉ có 1 bậc chỉ có một cách bước.
+            return 1;
+        }
+
+        if (stairsNum === 2) {
+            // Nếu có hai bậc có hai cách bước là (1+1) và (2).
+            return 2;
+        }
+
+        // Tránh đệ quy cho các bước đã tính toán gần đây.
+        if (memo[stairsNum]) {
+            return memo[stairsNum];
+        }
+
+        // Tính tổng số bước ta cần thực hiện sau khi thực hiện một bước 
+        // với số bước ta cần thực hiện sau khi thực hiện hai bước lên.
+        memo[stairsNum] = getSteps(stairsNum - 1) + getSteps(stairsNum - 2);
+
+        return memo[stairsNum];
+    };
+
+    // Trả về các cách để có thể đi hết cầu thang.
+    return getSteps(totalStairs);
+}