面试必刷算法TOP101之动态规划篇 TOP15

题目来源：Leetcode

给定两个单词 word1 和 word2 ，返回使得 word1 和 word2 相同所需的最小步数。
每步 可以删除任意一个字符串中的一个字符

对于字符s[i]和字符t[j]来说获取最小删除次数必须依赖前边的数据所以这是典型的DP问题，所以直接套用动态规划的解题步骤
1、创建dp数组明确下边的含义
dp[i][j] 以i结尾的字符串s和以j结尾的字符串t，经过最小步数的修改元素达到相等的次数
2、递归公式
字符s[i]和t[j]相等，就取字符串s和字符串t的前i-1个前j-1个经过最小次数的修改到达相等,递归公式如下：
dp[i][j]=dp[i-1][j-1];
字符s[i]和t[j]不相等就有如下三种情况：
（1）删除s[i] 修改次数就是dp[i-1][j]+1(在前边的基础上加一次删除的次数)
（2）删除t[j] 修改次数就是dp[i][j-1]+1(在前边的基础上加一次删除的次数)
（3）同时删除s[i]、t[j]，就是在前边i-1和j-1基础删除删除了两次修改次数就是dp[i-1][j-1]+2（因为删除了2个字符）
因为这三种情况为一种大情况所以取这三种情况的最小值
3、初始化
对与dp数组的dp[i][0] 就是将字符串s的前i个字符删除为一个空串的最小修改次数，因为修改次数是字符串的长度，所以直接将dp[i][0]赋值为i
4、返回值
直接返回dp[n][m]

class Solution {
public:
    
    int minDistance(string word1, string word2) {
        int n=word1.size();
        int m=word2.size();
        vector>dp(n+1,vector(m+1,0));
        //初始化
        for(int i=0;i<=n;i++) dp[i][0]=i;
        for(int i=0;i<=m;i++) dp[0][i]=i;

        //dp
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                //相等
                if(word1[i-1]==word2[j-1]){
                    //将前边的得到的赋给现在的
                    dp[i][j]=dp[i-1][j-1];
                }
                //不相等
                else{
                dp[i][j]=min(min(dp[i-1][j]+1,dp[i][j-1]+1),dp[i-1][j-1]+2);
                }
            }
        }
        

return dp[n][m];
    }
};

题目来源：牛客网

对于长度为n的一个字符串A（仅包含数字，大小写英文字母），请设计一个高效算法，计算其中最长回文子串的长度。
数据范围： 1 le n le 10001≤n≤1000
要求：空间复杂度 O(1)O(1)，时间复杂度 O(n^2)O(n 2)
进阶: 空间复杂度 O(n)O(n)，时间复杂度 O(n)O(n)

对于区间【i，j】来说是不是回文串要依靠前边的区间[i+1,j-1]是不是回文串前边区间是回文串在此基础区间才有可能是回文串，所以后边结果也要依赖于前边的结果，所以这是一个DP问题，按照动态规划解题步骤来就可以
1、创建dp数组明确下标的含义
dp[i][j]:表示区间为[i,j]为回文串的最大长度
2、递推公式
对于字符s[i]和字符s[j]相等来说，先判断子区间【i+1,j-1】是不是回文串，若果是递推公式dp[i][j]=dp[i+1][j-1]+2(因为一次加两个字符)
不是就和下边的情况一样，先说下边的情况
字符s[i]和字符s[j]不相等，就是说字符s[i]和字符s[j]假如后来说并没有让回文串的长度增加，所以分别加入字符s[i]和s[j]来求取最长回文串长度
(1) 加入字符s[i]回文串长度为dp[i][j-1]
(2) 加入字符s[j] 回文串长度为dp[i+1][j]
所以直接取回文串最长的一个dp[i][j]=max(dp[i][j-1],dp[i+1][j]);
3、初始化
当i和j相等时对于字符串来说i和j相等是同一个字符所以将dp数组对应位置置为1，因为对与一个字符来说也是最简单的回文串
4、遍历顺序
因为后边结果要依赖下边的结果所以遍历顺序是反向的

class Solution {
public:
    
    bool _getLongestPalindrome(string s, int begin, int end) {
    while (begin <= end) {
        if (s[begin++] != s[end--]) {
            return false;
        }
    }
     return true;

    }
    int getLongestPalindrome(string A) {
       
        // write code here
        int n=A.size();
        vector> dp(n,vector(n,0));
        //初始化 对于每一个字符都是一个回文串，所以将区间【i,i】初始化为1
        for(int i=0;i=0;i--){
            for(int j=i+1;j
                //先判断是不是相等
                if(A[i]==A[j]){
                    //判断内区间是不是
                if (_getLongestPalindrome(A, i+1 , j-1 )) {
                     //在原来基础上加二
                    dp[i][j] = dp[i + 1][j - 1] + 2;
                }
                else {
                    dp[i][j] = max(dp[i][j - 1], dp[i + 1][j]);
                }
                //判断子区间是不是回文串

                  
                }else   if(A[i]!=A[j]){
                    dp[i][j]=max(dp[i][j-1],dp[i+1][j]);
                }
                
            }
        }
        return dp[0][n-1];
    }
};