LeetCode | Unique Paths【摘】

A robot is located at the top-left corner of a m x n grid (marked ‘Start’ in the diagram below). The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked ‘Finish’ in the diagram below). How many possible unique paths are there?

最简单的回溯：

 int backtrack(int r, int c, int m, int n) {
   if (r == m && c == n)
     return ;
   if (r > m || c > n)
     return ;

   return backtrack(r+, c, m, n) + backtrack(r, c+, m, n);
 }

用一个表记录状态，优化：

 const int M_MAX = ;
 const int N_MAX = ;

 int backtrack(int r, int c, int m, int n, int mat[][N_MAX+]) {
   if (r == m && c == n)
     return ;
   if (r > m || c > n)
     return ;

   if (mat[r+][c] == -)
     mat[r+][c] = backtrack(r+, c, m, n, mat);
   if (mat[r][c+] == -)
     mat[r][c+] = backtrack(r, c+, m, n, mat);

   return mat[r+][c] + mat[r][c+];
 }

 int bt(int m, int n) {
   int mat[M_MAX+][N_MAX+];
   for (int i = ; i < M_MAX+; i++) {
     for (int j = ; j < N_MAX+; j++) {
       mat[i][j] = -;
     }
   }
   return backtrack(, , m, n, mat);
 }

动态规划，从最靠近终点的地方（子问题）开始算：

 const int M_MAX = ;
 const int N_MAX = ;

 int dp(int m, int n) {
   int mat[M_MAX+][N_MAX+] = {};
   mat[m][n+] = ;

   for (int r = m; r >= ; r--)
     for (int c = n; c >= ; c--)
       mat[r][c] = mat[r+][c] + mat[r][c+];

   return mat[][];
 }

这里的空间可以进一步优化，因为最底行计算完之后可以直接用来计算上一行。

 class Solution {
 public:
     int uniquePaths(int m, int n) {
         vector<int> map(m+, );
         map[]=;
         for(int i=; i<n; i++){
             for(int j=; j<=m; j++)
                 map[j] = map[j-]+map[j];
         }
         return map[m];
     }
 }

另外，这道题其实也是一个组合数学的题，结果就是C(m + n - 2, n - 1)。这里要注意计算是overflow。

 int gcd(int a, int b) {
     while(b) {
         int c = a%b;
         a = b;
         b = c;
     }
     return a;
 }

 int C(int m, int n) {
     if(m - n < n) {
         n = m - n;
     }
     int result = ;
     for(int i = ; i <= n; i++) {
         int mult = m;
         int divi = i;
         int g = gcd(mult,divi);
         mult /= g;
         divi /= g;
         result /= divi;
         result *= mult;
         m--;
     }
     return result;
 }

这道题真是相当经典。