Add unique paths

Author: Ren0503

src/algorithms/others/unique-paths/README.md

@@ -0,0 +1,94 @@
+# Bài Toán Đường Đi Đơn Nhất
+
+Một con robot ở vị trí trên cùng bên trái của lưới `m x n` (đánh dấu 'Start' ở biểu đồ bên dưới).
+
+Robot có thể đi xuống hoặc qua phải đến bất kỳ điểm nào. Robot sẽ đi đến vị trí dưới cùng bên phải của lưới (đánh dấu 'Finish' ở biểu đồ bên dưới).
+
+Có bao nhiều đường đi đơn nhất?
+
+![Unique Paths](https://leetcode.com/static/images/problemset/robot_maze.png)
+
+## Ví dụ
+
+**Ví dụ 1**
+
+```
+Input: m = 3, n = 2
+Output: 3
+Giải thích:
+Từ góc trên trái, ta có ba cách để tới góc dưới phải:
+1. Phải -> Phải -> Xuống
+2. Phải -> Xuống -> Phải
+3. Xuống -> Phải -> Phải
+```
+
+**Ví dụ 2**
+
+```
+Input: m = 7, n = 3
+Output: 28
+```
+
+## Giải thuật
+
+### Quay lùi
+
+Ý tưởng đầu tiên là ta sẽ xây dựng một cây lựa chọn trong đó `D` có nghĩa là đi xuống và `R` có nghĩa là sang phải. Ví dụ trong trường bảng `width = 3` và `height = 2` ta sẽ có cây lựa chọn sau:
+
+```
+                START
+                /   \
+               D     R
+             /     /   \
+           R      D      R
+         /      /         \
+        R      R            D
+
+       END    END          END
+```
+
+Ta có thể thấy ba đường đi đơn nhất để trả lời cho vấn đề trên.
+
+**Độ phức tạp thời gian**: `O(2 ^ n)` - gần với trường hợp xấu nhất bảng vuông có kích thước `n`.
+
+**Độ phức tạp không gian mở rộng**: `O(m + n)` - vì ta cần lưu trữ đường đi hiện tại với các vị trí.
+
+### Quy hoạch động
+
+Hãy xem `BOARD[i][j]` là vấn đề phụ của ta.
+
+Vì ta có giới hạn chỉ được di chuyển sang phải và xuống, nên ta có thể nói rằng số lượng đường đi đơn nhất đến ô hiện tại là tổng số đường đi đơn nhất đến ô phía trên ô hiện tại và đến ô bên trái ô hiện tại.
+
+```
+BOARD[i][j] = BOARD[i - 1][j] + BOARD[i][j - 1]; // vì ta chỉ có thể đi xuống hoặc sang phải.
+```
+
+Các trường hợp cơ bản là:
+
+```
+BOARD[0][any] = 1; // chỉ có một cách đi đến bất kỳ ô nào ở hàng trên cùng.
+BOARD[any][0] = 1; // chỉ có một cách đi đến bất kỳ ô nào ở cột ngoài cùng bên trái.
+```
+
+Ví dụ với bảng `3 x 2` ta có ma trận quy hoạch động như sau:
+
+|     | 0   | 1   | 1   |
+|:---:|:---:|:---:|:---:|
+|**0**| 0   | 1   | 1   |
+|**1**| 1   | 2   | 3   |
+
+Mỗi ô chứa số lượng đường đi đơn nhất đến nó. Ở dưới cùng bên phải ta có số `3`.
+
+**Độ phức tạp thời gian**: `O(m * n)` - vì ta đi qua từng ô của ma trận quy hoạch động
+
+**Độ phức tạp không gian mở rộng**: `O(m * n)` - vì ta cần ma trận quy hoạch động
+
+### Tam giác Pascal
+
+Bài toán này thực chất là một dạng khác của Tam giác Pascal.
+
+Góc của hình chữ nhật này nằm ở dòng `m + n - 2` và ở vị trí `min (m, n) - 1` của tam giác Pascal.
+
+## Liên kết
+
+- [LeetCode](https://leetcode.com/problems/unique-paths/description/)

src/algorithms/others/unique-paths/btUniquePaths.js

@@ -0,0 +1,57 @@
+/**
+ * Giải pháp QUAY LÙI để giải bài toán Đường Đi Đơn Nhất.
+ *
+ * @param {number} width - Chiều dài của bảng.
+ * @param {number} height - Chiểu rộng của bảng.
+ * @param {number[][]} steps - Các bước đã được thực hiện.
+ * @param {number} uniqueSteps - Tổng số bước đơn nhất.
+ * @return {number} - Số đường đi đơn nhất.
+ */
+export default function btUniquePaths(width, height, steps = [[0, 0]], uniqueSteps = 0) {
+    // Tìm nạp vị trí hiện tại trên bảng.
+    const currentPos = steps[steps.length - 1];
+
+    // Kiểm tra nếu ta đi đến cuối.
+    if (currentPos[0] === width - 1 && currentPos[1] === height - 1) {
+        // Trong trường hợp nếu ta đã hoàn thành, 
+        // hãy tăng tổng số bước duy nhất.
+        return uniqueSteps + 1;
+    }
+
+    // Hãy tính xem ta sẽ có bao nhiêu con đường đơn nhất
+    // bằng cách đi sang phải và đi xuống.
+    let rightUniqueSteps = 0;
+    let downUniqueSteps = 0;
+
+    // Sang phải nếu có thể.
+    if (currentPos[0] < width - 1) {
+        steps.push([
+            currentPos[0] + 1,
+            currentPos[1],
+        ]);
+
+        // Tính xem ta sẽ đi được bao nhiêu đường đơn nhất bằng cách di chuyển sang phải.
+        rightUniqueSteps = btUniquePaths(width, height, steps, uniqueSteps);
+
+        // QUAY LÙI và thực hiên bước khác.
+        steps.pop();
+    }
+
+    // Đi xuống nếu có thể.
+    if (currentPos[1] < height - 1) {
+        steps.push([
+            currentPos[0],
+            currentPos[1] + 1,
+        ]);
+
+        // Tính xem ta sẽ đi được bao nhiêu đường đơn nhất bằng cách di chuyển xuống.
+        downUniqueSteps = btUniquePaths(width, height, steps, uniqueSteps);
+
+        // QUAY LÙI và thực hiên bước khác.
+        steps.pop();
+    }
+
+    // Tổng số bước đơn nhất sẽ bằng tổng số bước đơn nhất bằng cách  
+    // sang phải cộng với tổng số bước đơn nhất bằng cách đi xuống.
+    return rightUniqueSteps + downUniqueSteps;
+}

src/algorithms/others/unique-paths/dpUniquePaths.js

@@ -0,0 +1,39 @@
+/**
+ * Giải pháp QUY HOẠCH ĐỘNG để giải bài toán Đường Đi Đơn Nhất.
+ * 
+ * @param {number} width - Chiều dài của bảng.
+ * @param {number} height - Chiểu rộng của bảng.
+ * @return {number} - Số đường đi đơn nhất.
+ */
+export default function dpUniquePaths(width, height) {
+    // Khởi tạo bảng.
+    const board = Array(height).fill(null).map(() => {
+        return Array(width).fill(0);
+    });
+
+    // Trường hợp cơ bản.
+    // Chỉ có một cách để đến board[0][any] và cũng 
+    // chỉ có một cách để đến board[any][0]. Điều này là do ta bị hạn chế 
+    // chỉ di chuyển sang phải và xuống.
+    for (let rowIndex = 0; rowIndex < height; rowIndex += 1) {
+        for (let columnIndex = 0; columnIndex < width; columnIndex += 1) {
+            if (rowIndex === 0 || columnIndex === 0) {
+                board[rowIndex][columnIndex] = 1;
+            }
+        }
+    }
+
+    // Bây giờ, vì ta bị hạn chế là chỉ di chuyển sang phải và xuống, 
+    // ta có thể nói rằng số lượng đường đi đơn nhất đến ô hiện tại 
+    //là tổng số đường đi đơn nhất đến ô phía trên ô hiện tại 
+    // và đến ô bên trái của hiện tại.
+    for (let rowIndex = 1; rowIndex < height; rowIndex += 1) {
+        for (let columnIndex = 1; columnIndex < width; columnIndex += 1) {
+            const uniquesFromTop = board[rowIndex - 1][columnIndex];
+            const uniquesFromLeft = board[rowIndex][columnIndex - 1];
+            board[rowIndex][columnIndex] = uniquesFromTop + uniquesFromLeft;
+        }
+    }
+
+    return board[height - 1][width - 1];
+}

src/algorithms/others/unique-paths/uniquePaths.js

@@ -0,0 +1,13 @@
+import pascalTriangle from '../../math/pascal-triangle/pascalTriangle';
+
+/**
+ * @param {number} width
+ * @param {number} height
+ * @return {number}
+ */
+export default function uniquePaths(width, height) {
+    const pascalLine = width + height - 2;
+    const pascalLinePosition = Math.min(width, height) - 1;
+
+    return pascalTriangle(pascalLine)[pascalLinePosition];
+}