复习115不同的子序列
class Solution {
public:
int numDistinct(string s, string t) {
//采用动态规划的方式进行迭代，同时，题设使用的是字符，所以使用vector的时候应当使用unint64_t模板
vector<vector<uint64_t>> dp(s.size() + 1, vector<uint64_t>(t.size() + 1));
//在递推迭代公式的基础上，应当对最上行和最右列初始化
//思考怎么对列进行初始化，因为dp[i][0]存储以i-1为结尾的数组种，含有空字符串的个数，初始化为1
for(int i=0;i<=s.size();i++){
dp[i][0]=1;
}
//dp[0][j]存储表示空字符串0含有以j-1为结尾的子字符串个数，所以应当初始化为0；
for(int i=0;i<=t.size();i++){
dp[0][i]=0;
}
//不要忘记初始化dp[0][0]=1;
dp[0][0]=1;
//执行递推迭代公式
for(int i=1;i<=s.size();i++){//从i=1开始，因为存储内容是指在i-1字符串内满足条件的长度，同理j=1；
for(int j=1;j<=t.size();j++){
//注意，满足匹配条件和不满足匹配条件的区别
if(s[i-1]==t[j-1]) dp[i][j]=dp[i-1][j-1]+dp[i-1][j];//前者是当前匹配时的个数，后者包括不匹配的其他情况
else
dp[i][j]=dp[i-1][j];
}
}
return dp[s.size()][t.size()];
}
};
583.两个字符串的删除操作 难点解析： 1.初始化的区别设计 2.状态转移方程的具体安排
class Solution {
public:
int minDistance(string word1, string word2) {
//采用动态规划算法
//设计二维dp数组，i,j分别表示遍历到word1第i个元素，word2第j个元素，存储前i-1，j-1个元素中需要删除多少个元素
vector<vector<int>> dp(word1.size()+1,vector<int>(word2.size()+1));//注意，规模必须加一
//初始化设计
//对列进行初始化
for(int i=0;i<=word1.size();i++) dp[i][0]=i;
//对行进行初始化
for(int i=0;i<=word2.size();i++) dp[0][i]=i;
//执行递推数组，引入状态转移方程
for(int i=1;i<=word1.size();i++){//注意是从1开始的
for(int j=1;j<=word2.size();j++){
if (word1[i - 1] == word2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1];
} else {
dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1);
}
}
}
return dp[word1.size()][word2.size()];
}
};
72.编辑距离 难点在于状态转移方程的解析 在确定递推公式的时候，首先要考虑清楚编辑的几种操作，整理如下：
if (word1[i - 1] == word2[j - 1])
不操作
if (word1[i - 1] != word2[j - 1])
增
删
换
也就是如上4种情况。
if (word1[i - 1] == word2[j - 1]) 那么说明不用任何编辑，dp[i][j] 就应该是 dp[i - 1][j - 1]，即dp[i][j] = dp[i - 1][j - 1];
此时可能有同学有点不明白，为啥要即dp[i][j] = dp[i - 1][j - 1]呢？
那么就在回顾上面讲过的dp[i][j]的定义，word1[i - 1] 与 word2[j - 1]相等了，那么就不用编辑了，以下标i-2为结尾的字符串word1和以下标j-2为结尾的字符串word2的最近编辑距离dp[i - 1][j - 1]就是 dp[i][j]了。
在下面的讲解中，如果哪里看不懂，就回想一下dp[i][j]的定义，就明白了。
在整个动规的过程中，最为关键就是正确理解dp[i][j]的定义！
if (word1[i - 1] != word2[j - 1])，此时就需要编辑了，如何编辑呢？
- 操作一：word1删除一个元素，那么就是以下标i - 2为结尾的word1 与 j-1为结尾的word2的最近编辑距离 再加上一个操作。
即 dp[i][j] = dp[i - 1][j] + 1;
- 操作二：word2删除一个元素，那么就是以下标i - 1为结尾的word1 与 j-2为结尾的word2的最近编辑距离 再加上一个操作。
即 dp[i][j] = dp[i][j - 1] + 1;
这里有同学发现了，怎么都是删除元素，添加元素去哪了。
word2添加一个元素，相当于word1删除一个元素，例如 word1 = "ad" ，word2 = "a"，word1删除元素'd' 和 word2添加一个元素'd'，变成word1="a", word2="ad"， 最终的操作数是一样！ dp数组如下图所示意的：
a a d
+-----+-----+ +-----+-----+-----+
| 0 | 1 | | 0 | 1 | 2 |
+-----+-----+ ===> +-----+-----+-----+
a | 1 | 0 | a | 1 | 0 | 1 |
+-----+-----+ +-----+-----+-----+
d | 2 | 1 |
+-----+-----+
操作三：替换元素，word1替换word1[i - 1]，使其与word2[j - 1]相同，此时不用增删加元素。
可以回顾一下，if (word1[i - 1] == word2[j - 1])的时候我们的操作 是 dp[i][j] = dp[i - 1][j - 1] 对吧。
那么只需要一次替换的操作，就可以让 word1[i - 1] 和 word2[j - 1] 相同。
所以 dp[i][j] = dp[i - 1][j - 1] + 1;
综上，当 if (word1[i - 1] != word2[j - 1]) 时取最小的，即：dp[i][j] = min({dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]}) + 1;
647.回文子串 动态规划方法 难点解析： 1.dp数组的设计，下标自然表示数组的遍历下标，需要采用双指针，但是存储内容应当选择bool类型 2.递推状态转移公式的设计，建议使用二维数组画图解决 3.遍历顺序的设计，在理解1，2的基础上进行遍历设计
class Solution {
public:
int countSubstrings(string s) {
//采用动态规划解决问题
//设计dp数组，下标i，j为双指针，内容存储表示在i+1，j-1范围内是否为回文字符串,并初始化为false
vector<vector<bool>> dp(s.size()+1,vector<bool>(s.size()+1,false));
//使用result记录
int result=0;
//执行状态转移公式并且设计遍历顺序，从左下遍历到右上
for(int i=s.size()-1;i>=0;i--){
for(int j=i;j<s.size();j++){
if (s[i] == s[j]) //回文出现三种情况情况一，单字符情况，情况二，双字符情况，情况三，在之前的递推基础上进行迭代
if (j - i <= 1) { // 情况一 和 情况二
result++;
dp[i][j] = true;
} else if (dp[i + 1][j - 1]) { // 情况三
result++;
dp[i][j] = true;
}
}
}
return result;
}
};
双指针法，相对节省空间
class Solution {
public:
int countSubstrings(string s) {
int result = 0;
for (int i = 0; i < s.size(); i++) {
result += extend(s, i, i, s.size()); // 以i为中心
result += extend(s, i, i + 1, s.size()); // 以i和i+1为中心
}
return result;
}
int extend(const string& s, int i, int j, int n) {
int res = 0;
while (i >= 0 && j < n && s[i] == s[j]) {
i--;
j++;
res++;
}
return res;
}
};
516.最长回文子序列
要仔细设计dp数组来判断
class Solution {
public:
int longestPalindromeSubseq(string s) {
//采用动态规划的方法进行
//设计dp数组，dp[i][j]表示[i,j]范围内的最长回文串
vector<vector<int>> dp(s.size(),vector<int>(s.size(),0));//注意同回文子串相互区分，这里的定义有区别
//初始化
for(int i=0;i<s.size();i++) dp[i][i]=1;
//执行递推和迭代公式设计,确定遍历顺序为左下至右上
for(int i=s.size()-1;i>=0;i--){
for(int j=i+1;j<s.size();j++){
if(s[i]==s[j]){
dp[i][j]=dp[i+1][j-1]+2;
}
else{
dp[i][j]=max(dp[i+1][j],dp[i][j-1]);
}
}
}
return dp[0][s.size() - 1];
}
};
