【leetcode】dp---中等（1）**5. 最长回文子串_dp回文_对长度进行转移（2）62. 不同路径_dp迷宫（3）63. 不同路径 II_dp迷宫_有障碍

5、给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。

示例 2：

输入: "cbbd"
输出: "bb"

 dp[i][j] = (dp[i+1][j-1]) && (s[i]==s[j]);     dp[i][i] = 1;      dp[i][j] = (s[i]==s[j]);

// dp[i][j]:从下标i到下标j的子串，是否为回文。0：否；else 回文串长度。
// 状态转移：从长度短的转移至长度长的，大循环len：1<len<n
//          两种回文：aba,bb; 需要分两类讨论
// dp[i][j] = (dp[i+1][j-1]) && (s[i]==s[j]); dp[i][i] = 1; dp[i][j] = (s[i]==s[j]);

int dp[1010][1010];
class Solution {
public:
    string longestPalindrome(string s) {
        memset(dp,0,sizeof(dp));
        int n = s.size();
        string ans = "";
        for(int len = 0; len < n; len++){
            for(int i = 0; i + len < n; i++){
                int j = i + len;
                if(len == 0) dp[i][i] = 1;
                else if(len == 1) dp[i][j] = (s[i] == s[j]);
                else dp[i][j] = (dp[i+1][j-1]) && (s[i] == s[j]);
                if(dp[i][j] && (len + 1 > ans.size())) ans = s.substr(i, len + 1);
            }
        }
        return ans;
    }
};

结果：

执行用时：184 ms, 在所有 C++ 提交中击败了52.86% 的用户

内存消耗：18.6 MB, 在所有 C++ 提交中击败了50.28% 的用户

 

62、一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。

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

问总共有多少条不同的路径？

例如，上图是一个7 x 3 的网格。有多少可能的路径？

示例 1:

输入: m = 3, n = 2
输出: 3
解释:
从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向右 -> 向下
2. 向右 -> 向下 -> 向右
3. 向下 -> 向右 -> 向右

 dp[i][j] = dp[i-1][j] + dp[i][j-1]

// dp[i][j]:到达(i,j)格子有多少条路径
// 状态转移：1)从左边格子右走一步，2)从上边格子下走一步
// dp[i][j] = dp[i-1][j] + dp[i][j-1]
class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for(int i = 0; i < m; i++) dp[i][0] = 1;
        for(int j = 0; j < n; j++) dp[0][j] = 1;
        for(int i = 1; i < m; i++)
            for(int j = 1; j < n; j++)
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
        return dp[m-1][n-1];
    }
};

结果：

执行用时：4 ms, 在所有 C++ 提交中击败了29.82% 的用户

内存消耗：6.7 MB, 在所有 C++ 提交中击败了16.96% 的用户

 

修改：不单独初始化dp[0][j], dp[i][0]

// dp[i][j]:到达(i,j)格子有多少条路径
// 状态转移：1)从左边格子右走一步，2)从上边格子下走一步
// dp[i][j] = dp[i-1][j] + dp[i][j-1]

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++){
                if(i==0 || j ==0) dp[i][j] = 1;  // 修改处！！！！！！！
                else dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        return dp[m-1][n-1];
    }
};

结果：

执行用时：0 ms, 在所有 C++ 提交中击败了100.00% 的用户

内存消耗：6.5 MB, 在所有 C++ 提交中击败了43.83% 的用户

 

63、一个机器人位于一个 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. 向下 -> 向下 -> 向右 -> 向右

 不单独初始化，分五类讨论 g[i][j]==1;     i==0&&j==0;  i==0;    j==0;        i!=0&&j!=0。中间三类属于初始化行列

// dp[i][j] : 到位置(i,j)的方法数
// 状态转移：1）从左走一步，2）从上方走一步，3）当前(i,j)为障碍物时，dp=0。
// dp[i][j] = dp[i-1][j] + dp[i][j-1] || dp[i][j] = 0;
class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& grid) {
        for(int i = 0; i < grid.size(); i++){
            for(int j = 0; j < grid[0].size(); j++){
                if(grid[i][j])  grid[i][j] = 0;
                else if(i == 0 && j == 0) grid[i][j] = !grid[i][j];
                else if(i == 0 ) grid[i][j] = grid[i][j-1];
                else if(j == 0 ) grid[i][j] = grid[i-1][j];
                else  grid[i][j] = grid[i-1][j] + grid[i][j-1];
            }
        }
        return grid[grid.size()-1][grid[0].size()-1];
    }
};

结果：

执行用时：4 ms, 在所有 C++ 提交中击败了95.68% 的用户

内存消耗：7.6 MB, 在所有 C++ 提交中击败了96.73% 的用户