Unique Paths：寻径问题

原文转自：http://blog.csdn.net/linhuanmars/article/details/22126357，原文中有错别字，我就没有更改。如果作者对转载不满意，请联系我，修改至满意为止。

另外，组合数公式

解法中的组合数公式是（5*4）/（2*1），没有用（5*4*3*2*1）/（（3*2*1）*（2*1））

原文：

原题链接: http://oj.leetcode.com/problems/unique-paths/ 
这道题是比较典型的动态规划的题目。模型简单，但是可以考核动态规划的思想。

我们先说说brute force的解法，比较容易想到用递归，到达某一格的路径数量等于它的上面和左边的路径数之和，结束条件是走到行或者列的边缘。因为每条路径都会重新探索，时间复杂度是结果数量的量级，不是多项式的复杂度。代码如下： 

[java]  view plain  copy

1. public int uniquePaths(int m, int n) {  
2.     return helper(1,1,m,n);  
3. }  
4. private int helper(int row, int col, int m, int n)  
5. {  
6.     if(row==m && col==n)  
7.         return 1;  
8.     if(row>m || col>n)  
9.         return 0;  
10.     return helper(row+1,col,m,n)+helper(row,col+1,m,n);  
11. }  

上面的代码放到LeetCode中跑会超时，因为不是多项式量级的。其实上一步中递推式已经出来了，就是res[i][j]=res[i-1][j]+res[i][j-1]，这样我们就可以用一个数组来保存历史信息，也就是在i行j列的路径数，这样每次就不需要重复计算，从而降低复杂度。用动态规划我们只需要对所有格子进行扫描一次，到了最后一个得到的结果就是总的路径数，所以时间复杂度是O(m*n)。而对于空间可以看出我们每次只需要用到上一行当前列，以及前一列当前行的信息，我们只需要用一个一维数组存上一行的信息即可，然后扫过来依次更替掉上一行对应列的信息即可（因为所需要用到的信息都还没被更替掉），所以空间复杂度是O(n)（其实如果要更加严谨，我们可以去行和列中小的那个，然后把小的放在内层循环，这样空间复杂度就是O(min(m,n))，下面的代码为了避免看起来过于繁杂，就不做这一步了，有兴趣的朋友可以实现一下，比较简单，不过代码有点啰嗦）。实现的代码如下：

[java]  view plain  copy

1. public int uniquePaths(int m, int n) {  
2.     if(m<=0 || n<=0)  
3.         return 0;  
4.     int[] res = new int[n];  
5.     res[0] = 1;  
6.     for(int i=0;i<m;i++)  
7.     {  
8.         for(int j=1;j<n;j++)  
9.         {  
10.            res[j] += res[j-1];  
11.         }  
12.     }  
13.     return res[n-1];  
14. }  

上面的方法用动态规划来求解，如果我们仔细的看这个问题背后的数学模型，其实就是机器人总共走m+n-2步，其中m-1步往下走，n-1步往右走，本质上就是一个组合问题，也就是从m+n-2个不同元素中每次取出m-1个元素的组合数。根据 组合 的计算公式，我们可以写代码来求解即可。代码如下：

[java]  view plain  copy

1. public int uniquePaths(int m, int n) {  
2.     double dom = 1;  
3.     double dedom = 1;  
4.     int small = m<n? m-1:n-1;  
5.     int big = m<n? n-1:m-1;  
6.     for(int i=1;i<=small;i++)  
7.     {  
8.         dedom *= i;  
9.         dom *= small+big+1-i;  
10.     }  
11.     return (int)(dom/dedom);  
12. }  

上面的代码求解了组合的结果，只需要做一次行或者列的扫描，所以时间复杂度是O(min(m,n))，而空间复杂度是O(1)。比起上面的两种解法更优。不过这里有个弊端，就是如果代码中的dom和dedom如果不是double，而是用int，那么会很容易越界，因为这是一个阶乘，所以大家在面试中讨论这种方法要注意和提及越界的问题。
上面介绍了几种方法来求解这个问题，其实都是比较简单的模型，只是提供了不同的思路。 Unique Paths II 是这道题的扩展，给机器人增加了障碍，有兴趣的朋友可以练习一下。