LeetCode_62

题意以及限制条件

1. 题目：

2. 限制条件：
   

想到的所有可能解法

• Ways_1——排列组合

  0. 时间复杂度——min(O(m), O(n))；空间复杂度——O(1)。
  1. 基础知识：
  2. 此代码模板为计算组合数的通用代码模板。

• Ways_2——DP1(顺推)

  0. 时间复杂度——O(mn)；空间复杂度——O(n);
  1. f[j]：从上往下从（0,0）到达位置（i - 1,j）的路径条数；
  2. f[j - 1]：从左往右从（0,0）到达位置（i,j - 1）的路径条数；
  3. 经过迭代计算后的f[j]：表示从位置（0,0）到达位置（i,j）的路径条数；
  4. 当且仅当（i,j）=（m - 1, n - 1）时，f[n - 1]存储即是最终的答案。

• Ways_3——DP2(逆推)

  0. 时间复杂度——O(mn)；空间复杂度——O(n)；
  1. f[j]：从下往上从（m - 1,n - 1）到达位置（i + 1,j）的路径条数（回退）；
  2. f[j + 1]：从右往左从（m - 1,n - 1）到达位置（i,j + 1）的路径条数（回退）；
  3. 经过迭代计算后的f[j]：表示从位置（i,j）到达位置（m - 1,n - 1）的路径条数；
  4. 当且仅当（i,j）=（0, 0）时，f[0]存储即是最终的答案。

• Ways_4——DP3(顺推)

  0. 时间复杂度——O(mn)；空间复杂度——O(mn)；
  1. dp[i - 1][j]：从上往下从（0,0）到达位置（i - 1,j）的路径条数；
  2. dp[i][j - 1]：从左往右从（0,0）到达位置（i,j - 1）的路径条数；
  3. 经过迭代计算后的dp[i][j]：表示从位置（0,0）到达位置（i,j）的路径条数；
  4. 当且仅当（i,j）=（m - 1, n - 1）时，dp[m - 1][n - 1]存储即是最终的答案。

• Ways_5——DP4(逆推)

  0. 时间复杂度——O(mn)；空间复杂度——O(mn)；
  1. dp[i + 1][j]：从下往上从（m - 1,n - 1）到达位置（i + 1,j）的路径条数（回退）；
  2. dp[i][j + 1]：从右往左从（m - 1,n - 1）到达位置（i,j + 1）的路径条数（回退）；
  3. 经过迭代计算后的[dp[i]j]：表示从位置（i,j）到达位置（m - 1,n - 1）的路径条数；
  4. 当且仅当（i,j）=（0, 0）时，dp[0][0]存储即是最终的答案。

• Ways_6——记忆化递归

  0. 时间复杂度——O(mn)；空间复杂度——O(mn)。

对应的代码

• Ways_1

class Solution {
    public int uniquePaths(int m, int n) {
		//解法1：排列组合
        long ans = 1;
        if (m > n) return uniquePaths(n, m);
        for (int x = n, y = 1; y < m; ++x, ++y) {
            ans = ans * x / y;
        }
        return (int) ans;
    }
}

• Ways_2

class Solution {
    public int uniquePaths(int m, int n) {
		//空间复杂度为O(n)的解法2——顺推
		int[] f = new int[n];
        f[0] = 1;
        for (int i = 0; i < m; ++i){
            for (int j = 1; j < n; ++j){
                f[j] += f[j-1] ;
            }
        }
        return f[n-1];
    }
}

• Ways_3

class Solution {
    public int uniquePaths(int m, int n) {
        //空间复杂度为O(n)的解法3——逆推
        int[] f = new int[n];
        f[n - 1] = 1;
        for (int i = m - 1; i >= 0; --i) {
            for (int j = n - 2; j >= 0; --j) {
                if (i == m - 1) {
                    f[j] = f[j + 1];
                } else {
                    f[j] += f[j + 1];
                }
            }
        }
        return f[0];
    }
}

• Ways_4

class Solution {
    public int uniquePaths(int m, int n) {
		//解法4：空间复杂度为O(mn)——顺推
        int[][] dp = new int[m][n];
        for (int i = 0; i < m; ++i) {
            dp[i][0] = 1;
        }
        for (int j = 1; j < n; ++j) {
            dp[0][j] = 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];
    }
}

• Ways_5

class Solution {
    public int uniquePaths(int m, int n) {
		//解法5：空间复杂度为O(mn)——逆推
        int[][] dp = new int[m][n];
        for (int i = m - 1; i >= 0; --i) {
            dp[i][n - 1] = 1;
        }
        for (int j = n - 2; j >= 0; --j) {
            dp[m - 1][j] = 1;
        }
        for (int i = m - 2; i >= 0; --i) {
            for (int j = n - 2; j >= 0; --j) {
                dp[i][j] = dp[i + 1][j] + dp[i][j + 1];
            }
        }
        return dp[0][0];
    }
}

• Ways_6

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] memo = new int[m][n];
        return helper(memo, 0, 0);
    }
    private int helper(int[][] memo, int i, int j) {
        //Terminator
        if (i == memo.length || j == memo[0].length) {
            return 0;
        }
        if (i == memo.length - 1 && j == memo[0].length - 1) {
            return 1;
        }
        //Current Logic && Drill Down
        return memo[i][j] = memo[i][j] == 0 ? helper(memo, i + 1, j) + helper(memo, i, j + 1) : memo[i][j];
        //Restore Current Data
    }
}

测试样例