Update unique_paths.cpp

Author: singhsayan

dynamic_programming/unique_paths.cpp

@@ -1,12 +1,15 @@
 /**
  * @file
- * @brief Implementation of Unique Paths problem using Dynamic Programming.
+ * @brief Implementation of Unique Paths (LeetCode 62) using Dynamic Programming.
  * @details
  * A robot is located at the top-left corner of an m × n grid.
  * The robot can move either down or right at any point in time.
  * This program computes the total number of unique paths to reach
  * the bottom-right corner.
  *
+ * Note: This is **Unique Paths I** (no obstacles). Obstacles are handled in
+ * the separate problem **Unique Paths II**.
+ *
  * Approaches:
  * - **Memoization (Top-Down)**: Recursively explores solutions while
  *   storing intermediate results in a cache (`memoization_table`) to avoid redundant
@@ -37,8 +40,9 @@ namespace dynamic_programming {
  */
 class UniquePathsSolver {
    private:
-    std::vector<std::vector<int>> memoization_table;  ///< Memoization table
-    int m, n;
+    std::vector<std::vector<int>> memoization_table;  ///< Memoization table to cache intermediate results
+    std::size_t m;  ///< Number of rows in the grid
+    std::size_t n;  ///< Number of columns in the grid
 
     /**
      * @brief Bottom-up Tabulation solution.
@@ -47,11 +51,11 @@ class UniquePathsSolver {
     int solveTabulation() {
         std::vector<std::vector<int>> table(m, std::vector<int>(n, 0));
 
-        for (int i = 0; i < m; i++) table[i][n - 1] = 1;  ///< last column
-        for (int j = 0; j < n; j++) table[m - 1][j] = 1;  ///< last row
+        for (std::size_t i = 0; i < m; i++) table[i][n - 1] = 1;  ///< last column
+        for (std::size_t j = 0; j < n; j++) table[m - 1][j] = 1;  ///< last row
 
-        for (int i = m - 2; i >= 0; i--) {
-            for (int j = n - 2; j >= 0; j--) {
+        for (int i = static_cast<int>(m) - 2; i >= 0; i--) {
+            for (int j = static_cast<int>(n) - 2; j >= 0; j--) {
                 table[i][j] = table[i + 1][j] + table[i][j + 1];
             }
         }
@@ -61,15 +65,20 @@ class UniquePathsSolver {
    public:
     /**
      * @brief Constructor initializes dimensions and memoization table
+     * @param rows number of rows in the grid (must be > 0)
+     * @param cols number of columns in the grid (must be > 0)
      */
-    UniquePathsSolver(int rows, int cols) : m(rows), n(cols) {
+    UniquePathsSolver(std::size_t rows, std::size_t cols) : m(rows), n(cols) {
         memoization_table.assign(m, std::vector<int>(n, -1));
     }
 
     /**
      * @brief Get number of unique paths using Memoization (Top-Down)
+     * @param i current row index (default = 0)
+     * @param j current column index (default = 0)
+     * @return int Number of unique paths from (i, j) to (m-1, n-1)
      */
-    int uniquePathsMemo(int i = 0, int j = 0) {
+    int uniquePathsMemo(std::size_t i = 0, std::size_t j = 0) {
         if (i >= m || j >= n) return 0;
         if (i == m - 1 && j == n - 1) return 1;
         if (memoization_table.at(i).at(j) != -1) return memoization_table.at(i).at(j);
@@ -81,6 +90,7 @@ class UniquePathsSolver {
 
     /**
      * @brief Get number of unique paths using Tabulation (Bottom-Up)
+     * @return int Number of unique paths from (0, 0) to (m-1, n-1)
      */
     int uniquePathsTabulation() { return solveTabulation(); }
 };