动态规划—简单级：简单的路径问题

一、路径问题描述

    路径问题一般场景描述如下：从a到b中间存在（少数没有）障碍，求总共有多少条路径？这个问题究竟应该怎么去寻找状态、确定路径呢？

二、例题

2.1 数字三角形

给定一个数字三角形，找到从顶部到底部的最小路径和。每一步可以移动到下面一行的相邻数字上。

样例

比如，给出下列数字三角形：

[
     [2],
    [3,4],
   [6,5,7],
  [4,1,8,3]
]

从顶到底部的最小路径和为11 ( 2 + 3 + 5 + 1 = 11)。

思路：其实这道题这样想就很简单了，从2开始向下走，每次只能向下方或者右下方移动。也就意味着从a[i][j]开始，它的下一步只能是a[i+1][j]或者a[i+1][j+1]。

既然思路有了，那接下来就是决定从上向下走还是从下向上走了！我这里采用的是从下向上走的方式，原因是最后只需要输出a[0][0]即可。

那么相应的状态方程就是： a[i][j] += min(a[i+1][j],a[i+1][j+1]);

所以code也就很简单了：

class Solution {
public:
    /**
     * @param triangle: a list of lists of integers
     * @return: An integer, minimum path sum
     */
    int minimumTotal(vector<vector<int>> &triangle) {
        // write your code here
        //from bottom to top
        int len1= triangle.size();
        for(int i=len1-2;i>=0;i--)
        {
            for(int j=0;j<=i;j++)
            {
                triangle[i][j] += min(triangle[i+1][j],triangle[i+1][j+1]);
            }
        }
        return triangle[0][0];
    }
};

2.2 最小路径和

给定一个只含非负整数的m*n网格，找到一条从左上角到右下角的可以使数字和最小的路径。

思路：这道题目与上面的题目类似，不同的是要求寻找的最短路径，那就意味着每次寻找的时候都需要记录下来，然后最后一次的时候比较所有路径的大小即可（这一步每次迭代都会体现出来，所以最后一步不需要比较了）。

我们用一个数组dist记录第1列开始，

class Solution {
public:
    /**
     * @param grid: a list of lists of integers
     * @return: An integer, minimizes the sum of all numbers along its path
     */
    int minPathSum(vector<vector<int>> &grid) {
        // write your code here
        if(grid.empty())
            return 0;
        int rows = grid.size();
        int cols = grid[0].size();
        vector<int> dis(rows,grid[0][0]);
        for(int i=1;i<rows;++i)
        {
            dis[i] = dis[i-1]+grid[i][0];
        }
        for(int j=1;j<cols;++j)
        {
            dis[0] += grid[0][j];
            for(int i=1;i<rows;++i)
            {
                dis[i] = min(dis[i-1],dis[i])+grid[i][j];
            }
        }
        return dis[rows-1];
    }
};

2.3 不同的路径

有一个机器人的位于一个 m × n 个网格左上角。

机器人每一时刻只能向下或者向右移动一步。机器人试图达到网格的右下角。

问有多少条不同的路径？

样例

给出 m = 3 和 n = 3, 返回 6.
给出 m = 4 和 n = 5, 返回 35.

class Solution {
public:
    /**
     * @param m: positive integer (1 <= m <= 100)
     * @param n: positive integer (1 <= n <= 100)
     * @return: An integer
     */
    int uniquePaths(int m, int n) {
        // write your code here
        int res[m][n]={0};
        for(int i=0;i<m;i++)
        {
            res[i][0] =1;
        }
        for(int j=0;j<n;j++)
        {
            res[0][j] =1;
        }
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                res[i][j] = res[i-1][j] + res[i][j-1];
            }
        }
        return res[m-1][n-1];
    }
};

2.4 不同的路径 II

2.3的跟进问题：

现在考虑网格中有障碍物，那样将会有多少条不同的路径？

网格中的障碍和空位置分别用 1 和 0 来表示。

样例

如下所示在3x3的网格中有一个障碍物：

[
  [0,0,0],
  [0,1,0],
  [0,0,0]
]

一共有2条不同的路径从左上角到右下角。

class Solution {
public:
    /**
     * @param obstacleGrid: A list of lists of integers
     * @return: An integer
     */
    int uniquePathsWithObstacles(vector<vector<int>> &obstacleGrid) {
        // write your code here
        int n=obstacleGrid.size();
        int m=obstacleGrid[0].size();
        if(n == 1)
            return 1;
        if(obstacleGrid[n-1][m-1] == 1)
            return 0;
        if(obstacleGrid[0][0] == 1)
            return 0;
        bool flag = true;
        for(int i=0;i<m;i++)
        {
            if(obstacleGrid[0][i] == 0&&flag)
                obstacleGrid[0][i] =1;
            else
            {
                obstacleGrid[0][i] = -1;
                flag = false;
            }
        }
        
        flag= true;
        for(int i=1;i<n;i++)
        {
            if(obstacleGrid[i][0] == 0&&flag)
            {
                obstacleGrid[i][0]=1;
            }
            else
            {
                obstacleGrid[i][0] = -1;
                flag = false;
            }
        }
        for(int i=1;i<n;i++)
        {   
            for(int j=1;j<m;j++)
            {
                if(obstacleGrid[i][j] ==1)
                {
                    obstacleGrid[i][j] =-1;
                    continue;
                }
                else
                {
                    int top=obstacleGrid[i-1][j];
                    int left=obstacleGrid[i][j-1];
                    if(top == -1) top =0;
                    if(left == -1) left=0;
                    obstacleGrid[i][j] = top+left;
                }
            }
        }
        return (obstacleGrid[n-1][m-1]>0)?obstacleGrid[n-1][m-1]:0;
    }
};