【LeetCode】解题62：Unique Paths

Problem 62: Unique Paths [Medium]

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?

Example 1:

Input: m = 3, n = 2
Output: 3
Explanation:
From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:

1. Right -> Right -> Down
2. Right -> Down -> Right
3. Down -> Right -> Right

Example 2:

Input: m = 7, n = 3
Output: 28

来源：LeetCode

解题思路

典型的动态规划题。
状态方程：
$$step[i,j]=step[i,j-1]+step[i-1,j]$$
每一格可以通过左边格/上边格到达，因此到达的方法个数为左边一格的方法个数与上边一格的方法个数之和。

具体思路：

• 由于状态方程中只用到了当前行和上一行的数据，因此不需要保存整个二维数组的数据，只需要两行数据。
• 创建两个长度为n的一维数组：step[n], last_step[n]。step用于计算当前行，last_step用于记录上一行数据。
• 双重循环，计算每行当前格方法个数公式：step[j] = step[j-1] + last_step[j]。
• 每行结束后，last_step更新为step。
• 减少存储空间：每格只需要上一行的当前列数据，其实也就是上一轮的自身值，因此可以缩减到只需要一个一维数组step[n]。

整个算法时间复杂度为$O(m\ast n)$，使用两个数组的方法一空间复杂度为$O(2n)$，使用一个数组的方法二空间复杂度为$O(n)$。

运行结果：

Solution (Java)

方法一：

class Solution {
    public int uniquePaths(int m, int n) {
        if (m == 1 || n == 1) return 1;
        int[] last_step = new int[n];
        int[] step = new int[n];
        Arrays.fill(last_step, 1);
        Arrays.fill(step, 1);
        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                step[j] = step[j-1] + last_step[j];
            }
            last_step = step.clone();
        }
        return last_step[n-1];
    }
}

方法二：

class Solution {
    public int uniquePaths(int m, int n) {
        if (m == 1 || n == 1) return 1;
        int[] step = new int[n];
        Arrays.fill(step, 1);
        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                step[j] += step[j-1];
            }
        }
        return step[n-1];
    }
}