区间型动态规划入门

状态表示与题目特点

题目会存在Subarray/Substring相关的字眼
用dp[i][j]表示数组/字符串中i，j这一段区间的最优值/可行性/方案总数
大的Subarray/Substring依赖于小的Subarray/Substring
dp[i][j]=max/min/sum/or(dp[i,j之内更小的若干区间])

判断回文子串

O(n^2)的算法中需要检测任意一段字符串是不是回文串

动规四要素
state:dp[i][j]表示i,j这一段是不是回文串
function:dp[i][j] = (dp[i+1][j-1] and s[i]==s[j])
initialization:dp[i][i]=true,dp[i][i+1]==(s[i]==s[i+1])
answer:dp[x][y]对于任意想要检测是否是回文串的下标范围x-y


前面依赖于后面，后面还未算到
解决方法（一）：i倒着循环，j正着循环
解决方案（二）：先循环区间长度，在循环区间起点，再计算终点j=i+length-1；

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

class Solution {
public:
    string longestPalindrome(string& s) {
        if(s.size()<2){
            return s;
        }
        int maxStart=0;
        int maxLen=1;
        vector<vector<bool>> dp(s.size(),vector<bool>(s.size(),false));
        for(int i=0;i<s.size();i++){
            dp[i][i]=true;
        }
        for(int L=2;L<=s.size();L++){
            for(int i=0;i<s.size();i++){
                int j=i+L-1;
                if(j>=s.size()){
                    break;
                }
                if(s[i]==s[j]&&(j-i<3||dp[i+1][j-1])){
                    dp[i][j]=true;
                }
                if(dp[i][j]&&j-i+1>maxLen){
                    maxLen=j-i+1;
                    maxStart=i;
                }
            }
        }
        return s.substr(maxStart,maxLen);
    }
};

石子归并游戏

石子排成一列，每次归并“相邻”的两堆石子，每次归并的耗费是两堆石子之和，求最小总耗费

state:dp[i][j]表示下标i合并到j的最小耗费
function:dp[i][j]=min(dp[i][k]+dp[k+1][j])+sum(i,j)，其中i<=k<j，sum(i,j)是i到j的子数组和
initialization:dp[i][j]=0
answer:dp[0][n-1]

可以使用prefixSum前缀和替代rangeSum来计算区间和（看见数组的时候可以想到），可以在系数上优化一点点，时间复杂度仍是O(n^3)，后面会继续优化到O(n^2)

爆气球

有一排气球，每个气球有一个分数，戳爆一个球能获得其左右两边两个气球和这个气球的分数乘积，找一个顺序戳破所有气球获得最大的积分。

状态表示：将整个数组前后增加1，[3,1,5]=>[1,3,1,5,1]
dp[i][j]表示戳破i和j之间所有气球之后（不含i,j）的最大积分
状态转移方程：寻找i和j之间最后一个被戳破的气球k，dp[i][j]=max{dp[i][k]+dp[k][j]+nums[i]*nums[k]*nums[j]},i<k<j
初始化：initialization:dp[i][i+1]=0
答案：dp[0][n-1]，n为增加了两个1之后的数组长度

区间型动态规划可以用滚动数组优化么？

不一定，石子和爆气球不一定依赖于哪一行，无法确定%几，回文串可以。需要判断依赖于哪一层。