动态规划问题--不同路径

63. 不同路径 II
    一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。

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

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。
说明：m 和 n 的值均不超过 100。
示例 1:
输入:
[
[0,0,0],
[0,1,0],
[0,0,0]
]
输出: 2
解释:
3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：

1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向下
   代码思路:
   定义最优解结构：令dp[i][j]表示(0,0)到(i,j)不同路径的数量。
   递推公式分析：
   到(i,j)这个点，可能是由(i-1,j)到达的，也可能由(i,j-1)到达，即dp[i][j]跟dp[i-1][j]和dp[i][j-1]有关
   稍微画下图，很显然，他们的关系是dp[i][j] = dp[i-1][j]+dp[i][j-1] (i >=1,j >= 1)。
   上述过程是主要的递推过程，现在解决边界问题。(因为对于上面的公式,边界上i-1,j-1会产生越界,所以单独处理边界)
   对于i = 0，dp[i][j] = dp[i][j-1];
   对于j = 0，dp[i][j] = dp[i-1][j];(当然，上述边界递推的起始条件dp[0][0]是已知)

ok，到现在为止还没有加上有障碍物的这个限制条件，那么现在加上这个条件，产生的影响就是这个点是此路不通。简而言之，如果(i,j)的值为1，那么dp[i][j] = 0，所以只要在上述所有的递推公式中加上这个限制条件即可

最后，还要加上一些特殊情况:

如果start(起始点)的值为1，则最终结果为0.
如果finish(终点)的值为1，则最终结果为0.
那么，现在还差dp[0][0]这个已知条件，很显然，根据上面的叙述，如果(0,0)处有障碍物，那么dp[0][0] = 0；
如果没有障碍物的话，可以从dp[i][j]的定义上看，从(0,0)到(0,0)是有路可走，那么说明dp[0][0] = 1
代码实现如下：

# -*- coding: cp936 -*-
class Solution(object):       
    def uniquePathsWithObstacles(self, obstacleGrid):
        """
        :type obstacleGrid: List[List[int]]
        :rtype: int
        """
        #求数组的行数
        m=len(obstacleGrid)
        #求数组的列数
        n=len(obstacleGrid[0])

        #如果左上角 或者右下角的数字为1则最终结果为0
        if obstacleGrid[0][0]==1 or obstacleGrid[m-1][n-1]==1 :
            return 0

        #如果(0,0)处有障碍物，那么dp[0][0] = 0；如果没有障碍物的话
        #可以从dp[i][j]的定义上看，从(0,0)到(0,0)是有路可走，那么说明dp[0][0] = 1
        obstacleGrid[0][0] = 1

        
        #边界上对于i = 0，dp[i][j] = dp[i][j-1]
        #对于j = 0，dp[i][j] = dp[i-1][j]
        for j in range(1,n):
            if obstacleGrid[0][j]==1:
                obstacleGrid[0][j]=0
            else:               
                obstacleGrid[0][j]=obstacleGrid[0][j-1]
        
        for i in range(1,m):
            if obstacleGrid[i][0]==1:
                obstacleGrid[i][0]=0
            else:
                obstacleGrid[i][0]=obstacleGrid[i-1][0]
                                   
        #到(i,j)这个点，可能是由(i-1,j)到达的，也可能
        #由(i,j-1)到达，即dp[i][j]跟dp[i-1][j]和dp[i][j-1]有关
        #稍微画下图，很显然，他们的关系是
        #dp[i][j] = dp[i-1][j]+dp[i][j-1] (i >=1,j >= 1)
        for i in range(1,m):
                for j in range(1,n):
                    #print i,j
                    if obstacleGrid[i][j]==0:
                        #print i,j
                        obstacleGrid[i][j]=obstacleGrid[i][j-1]+obstacleGrid[i-1][j]
                        #print obstacleGrid[i][j]
        #加上有障碍物的这个限制条件，那么现在加上这个条件，产生的影响就是这个点是
        #此路不通,简而言之，如果(i,j)的值为1，那么dp[i][j] = 0
                    else:
                        obstacleGrid[i][j]=0
                    '''if obstacleGrid[i][j]==1:
                        obstacleGrid[i][j]=0
                    else:
                        obstacleGrid[i][j]=obstacleGrid[i][j-1]+obstacleGrid[i-1][j]'''
        return obstacleGrid[m-1][n-1]

s=Solution()
print s.uniquePathsWithObstacles([[0,0,0],[0,1,0],[0,0,0]])