leetcode—动态规划(medium) 3/1

1.最长回文子串

给定一个字符串s，找到s中最长的回文子串。

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.length() == 0)
        {
            return s;
        }
        if(s.length() == 1)
        {
            return s;
        }
        int longest = 1;    //最大回文串的长度
        int start = 0;      //最大回文串的起始下标
        vector<vector<int>> dp(s.length(),vector<int>(s.length()));    
        for(int i = 0; i < s.length(); i++)
        {
            dp[i][i] = 1;
            
            if(i < s.length() - 1)    //判断由该字符和后一个字符组成的字符串是否是回文字符串
            {
                if(s[i] == s[i + 1])
                {
                    dp[i][i + 1] = 1;
                    start = i;      //回文字符串的起始下标仍是该字符
                    longest = 2;    //回文字符串的长度为2
                }
            }
        }
        
        for(int l = 3; l <= s.size(); l++)    //子串长度
        {
            for(int i = 0; i + l - 1 < s.length(); i++)    //枚举子串的起始点
            {
                int j = i + l - 1;  //终点
                if(s[i] == s[j] && dp[i + 1][j - 1] == 1)
                {
                    dp[i][j] = 1;
                    start = i;
                    longest = l;
                }
            }
        }
        return s.substr(start, longest);
    }
};

2.不同路径

一个机器人位于一个m×n网格的左上角，每次只能向下或者向右移动一步。机器人试图达到网格的右下角，总共有多少种不同的路径。

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

3.不同路径II

一个机器人位于一个m×n网格的左上角，每次只能向下或者向右移动一步。机器人试图达到网格的右下角，现在考虑网格中有障碍物，总共有多少种不同的路径。

思路：状态转移方程不变，有障碍物的格子dp设置为0。在边缘的时候判断一下。

4.最小路径和

给定一个包含非负整数的m×n网络，请找出 一条从左上角到右下角的路径，使得路径上的数字总和最小。每次只能向下或者向右移动一步。

思路：状态转移方程不变

5.解码方法

一条包含是数字A-Z的消息通过以下方式进行了编码
‘A’ -> 1
‘B’ -> 2
…
‘Z’ -> 26
给定一个只包含数字的非空字符串，请计算解码方法的总数

class Solution {
public:
    int numDecodings(string s) {
        vector<int> dp(s.size() + 1, 1);
        if(s.size() == 0 || s[0] == '0')
        {
            return 0;
        }
        for(int i = 2; i < dp.size(); i++)
        {
            //判断是否可以一位一位解码
            if(s[i - 1] == '0')
            {
                dp[i] = 0;
            }
            else
            {
                dp[i] = dp[i - 1];
            }
            //判断是否可以两位解码
            if((s[i - 2] == '1') || (s[i - 2] == '2' && s[i - 1] <= '6'))
            {
                dp[i] += dp[i - 2];
            }
        }
        return dp[dp.size() - 1];
    }
};