62. Unique Paths

62. Unique Paths

1. 题目
题目链接

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?

Above is a 7 x 3 grid. How many possible unique paths are there?
Note: m and n will be at most 100.
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

2. 题目分析
在一个m*n（注意，这个表示法跟我们平常用的不一样，这是一个n行m列的方格子）的方格子中，一个机器人从左上方到右下方的路径总数。并且机器人只能往右边或者下边走。

3. 解题思路
想要到达点(i,j)，机器人只能经过(i-1,j)或者(i,j-1)。到达(i,j)的路径数是，到达(i-1,j))的路径数与到达(i,j-1)的路径数之和。
按照我之前分析的动态规划的思路：

• 首先确定状态，用dp[i][j]表示到达（i,j）的路径总数；
• 初始化，对第0行的所有状态进行初始化，即dp[0][j] = 1；
• 对第0列的所有状态进行初始化，即dp[i][0] = 1;
• 找状态转移方程，dp[i][j] = dp[i-1][j] + dp[i][j-1];

4. 代码实现（java）

package com.algorithm.leetcode.dynamicAllocation;

/**
 * Created by 凌 on 2019/1/27.
 * 注释：62. Unique Paths
 */
public class UniquePaths {
    public static void main(String[] args) {
        int m =3;
        int n =2;
        int result = uniquePaths(m,n);
        System.out.println(result);
    }
    /**
     *
     * @param m 列数
     * @param n 行数
     * @return
     */
    public static int uniquePaths(int m, int n) {
        /*int[][] dp =new int[n+1][m+1];
        for (int j = 1; j <= m; j++) {
            dp[1][j] = 1;
        }
        for (int i = 1; i <= n; i++) {
            dp[i][1] = 1;
        }
        for (int i = 2; i <= n; i++) {
            for (int j = 2; j <= m; j++) {
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        return dp[n][m];*/
        //空间复杂度优化
        int[] dp =new int[m+1];
        for (int j = 1; j <= m; j++) {
            dp[j] = 1;
        }
        for (int i = 2; i <= n; i++) {
            dp[1] = 1;
            for (int j = 2; j <= m; j++) {
                dp[j] += dp[j-1];
            }
        }
        return dp[m];
    }
}