LintCode -- 不同的路径

LintCode -- unique-paths（不同的路径）

原题链接：http://www.lintcode.com/zh-cn/problem/unique-paths/

有一个机器人的位于一个M×N个网格左上角（下图中标记为'Start'）。

机器人 每一时刻 只能向下或者向右移动一步。机器人试图达到网格的右下角（下图中标记为 'Finish' ）。

问有多少条不同的路径？

您在真实的面试中是否遇到过这个题？  

Yes

样例

1,1	1,2	1,3	1,4	1,5	1,6	1,7
2,1
3,1						3,7

以上3 x 7的网格中，有多少条不同的路径？

注意

n和m均不超过100

分析：

dp[ n ][ m ] = dp[ n-1 ][ m ] + dp[ n ][ m-1 ]

时间复杂度 O（mn）    空间复杂度  O（m）

代码（C++、Python、Java）：

class Solution {
public:
    /**
     * @param n, m: positive integer (1 <= n ,m <= 100)
     * @return an integer
     */
    int uniquePaths(int m, int n) {
        // wirte your code here
        if (n == 1 || m == 1) return 1;
        if (n == 2) return m;
        if (m == 2) return n;
        int dp[2][m];
        for (int i = 0; i < m; i++){
            dp[0][i] = i + 1;
            dp[1][i] = i + 1;
        }
        for (int i = 3; i <= n; i++)
            for (int j = 1; j < m; j++)
                dp[i%2][j] = dp[(i-1)%2][j] + dp[i%2][j-1];
        return dp[n%2][m-1];        
    }
};

public class Solution {
    /**
     * @param n, m: positive integer (1 <= n ,m <= 100)
     * @return an integer
     */
    public int uniquePaths(int m, int n) {
        // write your code here 
        if (n == 1 || m == 1) return 1;
        if (n == 2) return m;
        if (m == 2) return n;
        int [][] dp = new int [2][m];
        for (int i = 0; i < m; i++){
            dp[0][i] = i + 1;
            dp[1][i] = i + 1;
        }
        for (int i = 3; i <= n; i++)
            for (int j = 1; j < m; j++)
                dp[i%2][j] = dp[(i-1)%2][j] + dp[i%2][j-1];
        return dp[n%2][m-1];
    }
}

class Solution:
    """
    @param n and m: positive integer(1 <= n , m <= 100)
    @return an integer
    """ 
    def uniquePaths(self, m, n):
        # write your code here
        if n == 1 or m == 1:
            return 1
        if n == 2:
            return m
        if m == 2:
            return n
        dp = [[i for i in range(1, m+1)] for j in range(2)]
        for i in range(3, n+1):
            for j in range(1, m):
                dp[i%2][j] = dp[(i-1)%2][j] + dp[i%2][j-1]
        return dp[n%2][m-1]