Add rain terraces

Author: Ren0503

README.md

@@ -147,38 +147,38 @@ Mô hình thuật toán là một phương pháp hoặc cách tiếp cận chung
 
 * **Phá mã Brute Force** - xem xét tất cả các khả năng và chọn giải pháp tốt nhất
   * `B` [Linear Search](src/algorithms/search/linear-search)
-  * `B` [Rain Terraces](src/algorithms/uncategorized/rain-terraces) 
-  * `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) 
+  * `B` [Rain Terraces](src/algorithms/others/rain-terraces) 
+  * `B` [Recursive Staircase](src/algorithms/others/recursive-staircase) 
   * `A` [Maximum Subarray](src/algorithms/sets/maximum-subarray)
   * `A` [Travelling Salesman Problem](src/algorithms/graph/travelling-salesman)
   * `A` [Discrete Fourier Transform](src/algorithms/math/fourier-transform) - biến đổi Fourier.
 * **Giải thuật tham lam** - chọn phương án tốt nhất tại thời điểm hiện tại mà không cần cân nhắc đến các lựa chọn khác trong tương lai.
-  * `B` [Jump Game](src/algorithms/uncategorized/jump-game)
+  * `B` [Jump Game](src/algorithms/others/jump-game)
   * `A` [Unbound Knapsack Problem](src/algorithms/sets/knapsack-problem)
   * `A` [Dijkstra Algorithm](src/algorithms/graph/dijkstra) 
   * `A` [Prim’s Algorithm](src/algorithms/graph/prim)
   * `A` [Kruskal’s Algorithm](src/algorithms/graph/kruskal)
 * **Giải thuật chia để trị** - chia nhỏ vấn đề và giải quyết các phần nhỏ đấy.
   * `B` [Binary Search](src/algorithms/search/binary-search)
-  * `B` [Tower of Hanoi](src/algorithms/uncategorized/hanoi-tower)
+  * `B` [Tower of Hanoi](src/algorithms/others/hanoi-tower)
   * `B` [Pascal's Triangle](src/algorithms/math/pascal-triangle)
   * `B` [Euclidean Algorithm](src/algorithms/math/euclidean-algorithm) 
   * `B` [Merge Sort](src/algorithms/sorting/merge-sort)
   * `B` [Quicksort](src/algorithms/sorting/quick-sort)
   * `B` [Tree Depth-First Search](src/algorithms/tree/depth-first-search) (DFS)
   * `B` [Graph Depth-First Search](src/algorithms/graph/depth-first-search) (DFS)
   * `B` [Matrices](src/algorithms/math/matrix) -tạo và duyệt các ma trận có hình dạng khác nhau.
-  * `B` [Jump Game](src/algorithms/uncategorized/jump-game)
+  * `B` [Jump Game](src/algorithms/others/jump-game)
   * `B` [Fast Powering](src/algorithms/math/fast-powering)
-  * `B` [Best Time To Buy Sell Stocks](src/algorithms/uncategorized/best-time-to-buy-sell-stocks)
+  * `B` [Best Time To Buy Sell Stocks](src/algorithms/others/best-time-to-buy-sell-stocks)
   * `A` [Permutations](src/algorithms/sets/permutations) 
   * `A` [Combinations](src/algorithms/sets/combinations) 
 * **Quy hoạch động** - xây dựng một giải pháp bằng cách sử dụng các giải pháp phụ đã tìm thấy trước đây.
   * `B` [Fibonacci Number](src/algorithms/math/fibonacci)
-  * `B` [Jump Game](src/algorithms/uncategorized/jump-game)
-  * `B` [Unique Paths](src/algorithms/uncategorized/unique-paths)
-  * `B` [Rain Terraces](src/algorithms/uncategorized/rain-terraces) 
-  * `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase)
+  * `B` [Jump Game](src/algorithms/others/jump-game)
+  * `B` [Unique Paths](src/algorithms/others/unique-paths)
+  * `B` [Rain Terraces](src/algorithms/others/rain-terraces) 
+  * `B` [Recursive Staircase](src/algorithms/others/recursive-staircase)
   * `B` [Seam Carving](src/algorithms/image-processing/seam-carving) - 
   * `A` [Levenshtein Distance](src/algorithms/string/levenshtein-distance)
   * `A` [Longest Common Subsequence](src/algorithms/sets/longest-common-subsequence) (LCS)
@@ -192,12 +192,12 @@ Mô hình thuật toán là một phương pháp hoặc cách tiếp cận chung
   * `A` [Floyd-Warshall Algorithm](src/algorithms/graph/floyd-warshall)
   * `A` [Regular Expression Matching](src/algorithms/string/regular-expression-matching)
 * **Giải thuật quay lùi** - tương tự brute force ta cũng tìm tất cả các khả năng nhưng trong quá trình tìm kiếm, nếu ta gặp một hướng lựa chọn không thỏa mãn, ta quay lui về điểm lựa chọn nơi có các hướng khác và thử hướng lựa chọn tiếp theo. Khi đã thử hết các lựa chọn xuất phát từ điểm lựa chọn đó, ta quay lại điểm lựa chọn trước đó và thử hướng lựa chọn tiếp theo tại đó. Quá trình tìm kiếm thất bại khi không còn điểm lựa chọn nào nữa
-  * `B` [Jump Game](src/algorithms/uncategorized/jump-game)
-  * `B` [Unique Paths](src/algorithms/uncategorized/unique-paths)
+  * `B` [Jump Game](src/algorithms/others/jump-game)
+  * `B` [Unique Paths](src/algorithms/others/unique-paths)
   * `B` [Power Set](src/algorithms/sets/power-set)
   * `A` [Hamiltonian Cycle](src/algorithms/graph/hamiltonian-cycle) 
-  * `A` [N-Queens Problem](src/algorithms/uncategorized/n-queens)
-  * `A` [Knight's Tour](src/algorithms/uncategorized/knight-tour)
+  * `A` [N-Queens Problem](src/algorithms/others/n-queens)
+  * `A` [Knight's Tour](src/algorithms/others/knight-tour)
   * `A` [Combination Sum](src/algorithms/sets/combination-sum) 
 * **Giải thuật nhánh cận** - ghi nhớ giải pháp chi phí thấp nhất được tìm thấy ở mỗi giai đoạn của tìm kiếm quay lùi, và sử dụng chi phí của giải pháp chi phí thấp nhất được tìm thấy như là một ràng buộc thấp hơn về chi phí của một giải pháp chi phí thấp nhất cho vấn đề, để loại bỏ các giải pháp với chi phí lớn hơn giải pháp chi phí thấp nhất được tìm thấy cho đến nay. 
 

src/algorithms/others/rain-terraces/README.md

@@ -0,0 +1,103 @@
+# Bài Toán Thềm Nước Mưa
+
+Cho một mảng số nguyên không âm biểu diễn các bậc thang trong bản đồ độ cao trong đó chiều rộng mỗi bậc là `1` đơn vị, hãy tính lượng nước còn lại trong thềm sau khi mưa.
+
+![Rain Terraces](https://www.geeksforgeeks.org/wp-content/uploads/watertrap.png)
+
+## Ví dụ
+
+**Ví dụ 1**
+
+```
+Input: arr[] = [2, 0, 2]
+Output: 2
+Cấu trúc thềm như sau:
+
+| |
+|_|
+
+Lượng nước đọng lại trong thềm là 2 đơn vị.
+```
+
+**Ví dụ 2**
+
+```
+Input: arr[] = [3, 0, 0, 2, 0, 4]
+Output: 10
+Cấu trúc thềm như sau:
+
+     |
+|    |
+|  | |
+|__|_| 
+
+Lượng nước đọng lại lúc này giữa bậc 3 và 2 là "3*2" đơn vị, trên đỉnh bậc 2 là "1" đơn vị, và giữa 2 và 4 là là "3" đơn vị. Tổng cộng là 10.
+
+```
+
+**Ví dụ 3**
+
+
+```
+Input: arr[] = [0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1]
+Output: 6
+Cấu trúc thềm như sau:
+
+       | 
+   |   || |
+_|_||_||||||
+
+Đọng "1" đơn vị giữa bậc 1 và 2, "4" đơn vị giữa bậc 2 và 3, và "1" đơn vị giữa 2 bậc 2.
+```
+
+## Giải thuật
+
+Một phần tử của mảng có thể đọng nước nếu có bậc cao hơn ở bên trái và phải. Ta có thể tìm lương nước đọng trong mọi phần tử bằng cách tìm chiều cao của các bậc bên trái và phải. Ý tưởng là tính toán lượng nước có thể lưu trữ trong mọi phần tử của mảng, ví dụ ta có mảng `[3, 0, 0, 2, 0, 4]`, ta có thể đọng "3*2" đơn vị giữa bậc 3 và 3, "1" đơn vị trên đỉnh bậc 2 và "3" đơn vị giữa 2 và 4. Xem sơ đồ dưới đây.
+
+
+### Giải pháp 1: Phá mã
+
+Với từng phần tử trong mảng, ta tìm lượng nước lớn nhất có thể đọng sau mưa,  bằng mức tối thiểu của chiều cao tối đa của các bậc ở cả hai bên trừ đi chiều cao của chính nó.
+
+**Bước**
+
+- Khởi tạo `answer = 0`
+- Lặp lại từ trái sang phải mảng:
+  - Khởi tạo `max_left = 0` và `max_right = 0`
+  - Lặp lại từ phần tử hiện tại đến khi phần bắt đầu thay đổi của mảng: `max_left = max(max_left, height[j])`
+  - Lặp lại từ phần tử hiện tại đến phần kết thúc thay đổi của mảng: `max_right = max(max_right, height[j])`
+  - Thêm `min(max_left, max_right) - height[i]` vào `answer`
+
+**Phân tích độ phức tạp**
+
+Độ phức tạp thời gian: `O(n^2)`. Với từng phần tử, ta phải lặp phần bên trái và bên phải.
+
+Độ phức tạp không gian mở rộng: `O(1)` không gian mở rộng
+
+### Giải pháp 2: Quy hoạch động
+
+Với giải pháp phá mã, ta phải lặp từ bên trái và bên phải mỗi lần để tìm ra bậc cao nhất tính đến chỉ số đó. Nhưng ta có thể lưu trữ chúng với quy hoạch động.
+
+Với quy hoạch động ta có thể tính toán trước bậc cao nhất ở bên trái và bên phải của mọi bậc trong thời gian `O (n)`. Sau đó, sử dụng các giá trị được tính toán trước này để tìm lượng nước trong mọi phần tử mảng.
+
+Khái niệm có thể mình hoạ như sau:
+
+![DP Trapping Rain Water](https://leetcode.com/problems/trapping-rain-water/Figures/42/trapping_rain_water.png)
+
+**Bước**
+
+- Tìm bậc cao nhất từ bên trái của chỉ số `i` trong mảng `left_max`
+- Tìm bậc cao nhất từ bên phải của chỉ số `i` trong mảng `right_max`
+- Lặp lại mảng `height` và cập nhật `answer`:
+  - Thêm `min(max_left[i], max_right[i]) - height[i]` vào `answer`.
+
+**Phân tích độ phức tạp**
+
+Độ phức tạp thời gian: `O(n)`. Ta lưu trữ độ cao lớn nhất đến một điểm bằng cách dùng 2 lần lặp lại `O(n)`. Cuối cùng cập nhật `answer` bằng giá trị đã lưu ở `O(n)`.
+
+Độ phức tạp không gian: `O(n)` không gian mở rộng. Bổ sung không gian cho mảng `left_max` và `right_max` so với giải pháp 1.
+
+## Liên kết
+
+- [GeeksForGeeks](https://www.geeksforgeeks.org/trapping-rain-water/)
+- [LeetCode](https://leetcode.com/problems/trapping-rain-water/solution/)

src/algorithms/others/rain-terraces/bfRainTerraces.js

@@ -0,0 +1,33 @@
+/**
+ * Giải pháp PHÁ MÃ để giải quyết bài toán Thềm Nước Mưa.
+ *
+ * @param {number[]} terraces
+ * @return {number}
+ */
+export default function bfRainTerraces(terraces) {
+    let waterAmount = 0;
+
+    for (let terraceIndex = 0; terraceIndex < terraces.length; terraceIndex += 1) {
+        // Lấy bậc cao nhất bên trái.
+        let leftHighestLevel = 0;
+        for (let leftIndex = terraceIndex - 1; leftIndex >= 0; leftIndex -= 1) {
+            leftHighestLevel = Math.max(leftHighestLevel, terraces[leftIndex]);
+        }
+
+        // Lấy bậc cao nhất bên phải.
+        let rightHighestLevel = 0;
+        for (let rightIndex = terraceIndex + 1; rightIndex < terraces.length; rightIndex += 1) {
+            rightHighestLevel = Math.max(rightHighestLevel, terraces[rightIndex]);
+        }
+
+        // Thêm lượng nước trên thềm hiện tại.
+        const terraceBoundaryLevel = Math.min(leftHighestLevel, rightHighestLevel);
+        if (terraceBoundaryLevel > terraces[terraceIndex]) {
+            // Thềm có thể đọng nước nếu phần thấp nhất của hai bậc cao nhất 
+            // bên trái và phải vẫn cao hơn bậc hiện tại
+            waterAmount += terraceBoundaryLevel - terraces[terraceIndex];
+        }
+    }
+
+    return waterAmount;
+}

src/algorithms/others/rain-terraces/dpRainTerraces.js

@@ -0,0 +1,47 @@
+/**
+ * Giải pháp QUY HOẠCH ĐỘNG để giải quyết bài toán Thềm Nước Mưa.
+ *
+ * @param {number[]} terraces
+ * @return {number}
+ */
+export default function dpRainTerraces(terraces) {
+    let waterAmount = 0;
+
+    // Khởi tạo mảng lưu trữ danh sách bậc cao nhất bên trái và phải của mỗi vị trí cụ thể.
+    const leftMaxLevels = new Array(terraces.length).fill(0);
+    const rightMaxLevels = new Array(terraces.length).fill(0);
+
+    // Tính bậc cao nhất từ bên TRÁI cho đến bậc hiện tại.
+    [leftMaxLevels[0]] = terraces;
+    for (let terraceIndex = 1; terraceIndex < terraces.length; terraceIndex += 1) {
+        leftMaxLevels[terraceIndex] = Math.max(
+            terraces[terraceIndex],
+            leftMaxLevels[terraceIndex - 1],
+        );
+    }
+
+    // Tính bậc cao nhất từ bên PHẢI cho đến bậc hiện tại.
+    rightMaxLevels[terraces.length - 1] = terraces[terraces.length - 1];
+    for (let terraceIndex = terraces.length - 2; terraceIndex >= 0; terraceIndex -= 1) {
+        rightMaxLevels[terraceIndex] = Math.max(
+            terraces[terraceIndex],
+            rightMaxLevels[terraceIndex + 1],
+        );
+    }
+
+    // Ta hãy lần lượt đi qua tất cả các bậc và tính toán lượng nước mà mỗi 
+    // bậc có thể đọng dựa trên các giá trị đã tính toán trước đó.
+    for (let terraceIndex = 0; terraceIndex < terraces.length; terraceIndex += 1) {
+        // Chọn bậc thấp nhất từ các bậc cao nhất bên trái/bên phải.
+        const currentTerraceBoundary = Math.min(
+            leftMaxLevels[terraceIndex],
+            rightMaxLevels[terraceIndex],
+        );
+
+        if (currentTerraceBoundary > terraces[terraceIndex]) {
+            waterAmount += currentTerraceBoundary - terraces[terraceIndex];
+        }
+    }
+
+    return waterAmount;
+}