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.