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 1;
  if (r > m || c > n)
    return 0;
 
  return backtrack(r+1, c, m, n) + backtrack(r, c+1, m, n);
}

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

const int M_MAX = 100;
const int N_MAX = 100;
 
int backtrack(int r, int c, int m, int n, int mat[][N_MAX+2]) {
  if (r == m && c == n)
    return 1;
  if (r > m || c > n)
    return 0;
 
  if (mat[r+1][c] == -1)
    mat[r+1][c] = backtrack(r+1, c, m, n, mat);
  if (mat[r][c+1] == -1)
    mat[r][c+1] = backtrack(r, c+1, m, n, mat);
 
  return mat[r+1][c] + mat[r][c+1];
}
 
int bt(int m, int n) {
  int mat[M_MAX+2][N_MAX+2];
  for (int i = 0; i < M_MAX+2; i++) {
    for (int j = 0; j < N_MAX+2; j++) {
      mat[i][j] = -1;
    }
  }
  return backtrack(1, 1, m, n, mat);
}

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

const int M_MAX = 100;
const int N_MAX = 100;
 
int dp(int m, int n) {
  int mat[M_MAX+2][N_MAX+2] = {0};
  mat[m][n+1] = 1;
 
  for (int r = m; r >= 1; r--)
    for (int c = n; c >= 1; c--)
      mat[r][c] = mat[r+1][c] + mat[r][c+1];
 
  return mat[1][1];
}

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

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<int> map(m+1, 0);
        map[1]=1;
        for(int i=0; i<n; i++){
            for(int j=1; j<=m; j++)
                map[j] = map[j-1]+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 = 1;
    for(int i = 1; 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;
}

这道题真是相当经典。