动态规划的思想是将一个复杂的问题转换为若干个子问题，并求子问题的最优解
大家最熟悉的应该是背包问题以及货币分配问题
下面是一道Leetcode上的题

分析过程
1.思路
用坐标（0,0）来表示开始位置，f(i,j)来表示从（0,0）开始走到终点（i,j）的路径数
机器人只能每次向右或向下移动一步，所以
f(i,j) 只能通过 f(i-1, j)和 f(i, j-1) 转移得到（向右，向下）
2.障碍
题目中有说到网格中会有障碍物，用动态规划的思路来看，遇到障碍不是简单的调头选择 其他路线，是该子问题无解
当（i, j）本身有障碍时，f(i, j)=0
当（i, j）本身没有障碍时f(i, j)=f(i-1, j)+f(i, j-1)

**用golang实现**

代码如下

func uniquePathsWithObstacles(obstacleGrid [][]int) int {
    m, n := len(obstacleGrid), len(obstacleGrid[0])//网格数
    dp := make([][]int, m)
        for i := 0; i < m; i ++ {
        for j := 0; j < n; j ++ {
            if obstacleGrid[i][j] == 1 {
                dp[i][j] = 0//本身有障碍
            } else {
                if i == 0 && j == 0 {
                    dp[i][j] = 1//本身就是终点
                } else if i == 0 {
                    dp[i][j] = dp[i][j-1]//考虑右边界
                } else if j == 0 {
                    dp[i][j] = dp[i-1][j]//考虑下边界
                } else {
                    dp[i][j] = dp[i][j-1] + dp[i-1][j]//路径数
                }
            }
        }
    }
    return dp[m-1][n-1]
}

也可以降维

func uniquePathsWithObstacles(obstacleGrid [][]int) int {
	n := len(obstacleGrid)
	m := len(obstacleGrid[0])//网格数
	dp :=make([]int, m) 
	if obstacleGrid [0][0]==0{
		dp[0] =1//坐标（0,0）即为终点，路径数为1
	}
	for i=0;i<=m;i++{
		for j=0;j<=n;j++{
			if obstacleGrid[i][j]==1{
				dp[j] =0//坐标（0,0）本身有障碍，路径数为0
			} 
			if j - 1 >= 0 {
				dp[j] = dp[j]+dp[j-1]//当向下移动时没有障碍，即得到总路径数
			}
	      }
		}
		return dp[len(dp)-1]//输出路径数
	}