LeetCode 62. Unique Paths

最新推荐文章于 2025-04-02 22:31:45 发布

原创最新推荐文章于 2025-04-02 22:31:45 发布 · 329 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 题解同时被 2 个专栏收录

288 篇文章

订阅专栏

Dynamic Programming

13 篇文章

订阅专栏

本文介绍了一种计算机器人从网格左上角到右下角所有唯一路径数量的算法。通过动态规划方法，文章展示了两种实现方式：一种使用二维矩阵存储中间结果；另一种采用滚动数组进一步优化空间复杂度。此外，还探讨了一个变化问题——从指定位置出发，在限定步数内到达起点的所有可能路径数量。

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.