[算法]给定一个矩阵m*n，从左上角开始每次只能向右或者向下走，最后到右下角的位置共有多少种路径

很经典的一道题

等同于：https://leetcode-cn.com/problems/unique-paths/

在完美世界面试中遇到了。

每次都只能向右或者向下走，求出所有种情况。

当时想到的思路是这样的。

dp[m][n]=dp[m-1][n]+dp[m][n-1]表示走到（m,n）位置的走法

给的题干是：

class Solution {
    public int uniquePaths(int m, int n) {

    }
}

这道题求有多少种路径？那么理应当想到动态规划。

我们令 dp[i][j] 是到达 i, j 最多路径

动态方程：dp[i][j] = dp[i-1][j] + dp[i][j-1]

跟上面公式是一样的。

对于第一行 dp[0][j]，或者第一列 dp[i][0]，由于都是在边界，所以只能为 1

时间复杂度：O(m*n)

空间复杂度：O(m * n)

这是：
作者：powcai
链接：https://leetcode-cn.com/problems/unique-paths/solution/dong-tai-gui-hua-by-powcai-2/

因为如果i=0的情况，路径肯定都是1

class Solution {
    public int uniquePaths(int m, int n) {
        //dp[i][j] 是到达 i, j 最多路径
        //但是为什么i= 0的时候 都要弄成1呢？
        //因为这是初始化过程最左边和最上面的都是1
        int[][] dp = new int[m][n];
        for (int i = 0; i < n; i++) dp[0][i] = 1;
        for (int i = 0; i < m; i++) dp[i][0] = 1;
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
}

优化1：

优化一：由于dp[i][j] = dp[i-1][j] + dp[i][j-1]，因此只需要保留当前行与上一行的数据 (在动态方程中，即pre[j] = dp[i-1][j])，两行，空间复杂度O(2n)；

 

其实就是：

当前的状态只跟上一行的状态和同一行左边的状态有关。所以我们只需要维护上一行的数组，和当前行的数组

那么pre就是上一行的状态(整行)

cur就是当前行整行的状态

nb!

class Solution {
    public int uniquePaths(int m, int n) {
         //上一行数据
        int[] pre = new int[n];
        int[] cur = new int[n];
        //初始化把所有的值都填成1
        Arrays.fill(pre, 1);
        Arrays.fill(cur,1);
        for (int i = 1; i < m;i++){
            for (int j = 1; j < n; j++){
                cur[j] = cur[j-1] + pre[j];
            }
            pre = cur.clone();
        }
        return pre[n-1]; 
    }
}

优化二：

cur[j] += cur[j-1], 即cur[j] = cur[j] + cur[j-1]

等价于思路二-->> cur[j] = pre[j] + cur[j-1]

因此空间复杂度为O(n).

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