LeetCode 62. Unique Paths

Question:

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?

This is a classical DP problem. The most important part is to initialize the status correctly.

  int uniquePaths(int m, int n) {
    vector< vector<int> > map(m, vector<int>(n, 0));

    // initialize the matrix
    for(int i = 0; i < m; ++i) {
        map[i][0] = 1;  // there is one one way to go right straightly.
    }

    for(int j = 0; j < n; ++j) {
        map[0][j] = 1;  // there is one way to go down straightly
    }

    for(int i = 1; i < m; ++i) {
        for(int j = 1; j < n; ++j) {
            map[i][j] = map[i-1][j] + map[i][j-1];  // the most recent cube path is from right top and left down.
        }
    }
    return map[m-1][n-1];  // the right down conner one is the sum of the whole path.
 }

Further optimize.... Space becomes O(N) using rolling array.

int waysII(int m, int n) {
  vector<int> prev(n, 1);
  for(int i = 1; i < m; ++i) {
    vector<int> curr(n, 1);
    for(int j = 1; j < n; ++j) {
      curr[j]= prev[j] + curr[j-1];
    }
    prev = curr;
  }
  return prev[n - 1];
}

Variation:

 Given a N * M matrix, and the point in the rectangle (x, y). search from (x, y) to (0, 0) at K steps. Every point can go for 4 directions.
 go left, right, up, down. For example, in the following matrix

  0, 0, 0, 0, 0
  0, 0, 0, 0, 0
  0, 0, 0, 0, 0
  0, 0, 0, 0, 0
  Given (x, y) = (1, 1), k = 2, return 2.

// dfs
void pathNumber(vector< vector<int> >& matrix, int x, int y, int &count, int k) {
  if(x < 0 || x >= matrix.size() || y >= matrix[0].size() || y < 0 || matrix[x][y] == -1 || k < 0) return;
  if((x == 0) && (y == 0) && (k == 0)) {
    count++;
    return;
  }
  matrix[x][y] = -1;
  pathNumber(matrix, x - 1, y, count, k - 1);
  matrix[x][y] = 0;
  pathNumber(matrix, x + 1, y, count, k - 1);
  matrix[x][y] = 0;
  pathNumber(matrix, x, y + 1, count, k - 1);
  matrix[x][y] = 0;
  pathNumber(matrix, x, y - 1, count, k - 1);
  matrix[x][y] = 0;
}

// first thought is to use dfs.
int pathNumber(vector< vector<int> >& matrix, int x, int y, int steps) {
  if(x == 0 || y == 0) return 1;
  int count = 0;
  pathNumber(matrix, x, y, count, steps);
  return count;
}

To further optimize it, we can use 3D dynamic programming.

dp[i][j][k] = dp[i-1][j][k-1] + dp[i+1][j][k-1] + dp[i][j-1][k-1]+dp[i][j+1][k-1]. initialize: dp[0][y][k] --- 1, dp[x][0][k] = 1

Maybe, can be further optimized using 2D array.