LeetCode刷题第五周——动态规划字符串问题

本周做题：

1. 戳气球
2. 分割等和子集
3. 奇怪的打印机
4. 统计不同的回文子序列
5. 多边形三角划分的最低得分

本周做题感悟

我相信动态规划的思考方式和微分的思考方式有严重的相似性。动态规划的思考着重两点：一是如何确定初始态；而是如何描述演变的过程（这里就包括了动态数组的含义以及状态转移方程的形成）。这周的题目太难了，一个也没有做出来。与其说是做题，不如说是看题。写这系列的博客的初衷就是因为看力扣官方解答都看不懂，要找好多资料才可以辅助看懂，所以为了日后更快的更快的找到题解思路而写的这一系列博客。本周做的题有一个共性，就是在$dp[i][j]$中的$[i,j]$范围内引入了一个变量$m$。这个$m$是求解此类问题的关键分析点。

戳气球

状态方程：
d p [ i ] [ j ] = m a x k = i + 1 , . . . , j − 1 { d p [ i ] [ k ] + d p [ k ] [ j ] + n u m s [ i ] ∗ n u m s [ k ] ∗ n u m s [ j ] } , i < j dp[i][j] = max_{k=i+1,...,j-1}\{dp[i][k]+dp[k][j]+nums[i]*nums[k]*nums[j]\},i < j dp[i][j]=maxk=i+1,...,j−1​{dp[i][k]+dp[k][j]+nums[i]∗nums[k]∗nums[j]},i<j
$elsedp[i][j]=0$
实现的一个难于思考的地方就是==如何确定该动态规划方程的循环次序问题？==可以这样想，$k\in [i+1,j-1]$k值是在这个制定范围变化的，要实现该动态方程，就要想办法将当前的k值变化范围依赖与上一次的k值范围。因为当前的k值所依赖的dp[i][k]和dp[k][j]必须要在上一轮循环中求出，所以其变化应该是自上而下的，即[length-1,lenght],[length-2,length],…[0,length]。

//核心算法实现
for(int i = length-1, i < length+1;++i){
	for(int j = i+2; j length+1; ++j){
		for(int k = i+1; k < j-1; ++k){
			sum = dp[i][k] + dp[k][j] + nums[i]*nums[k]*nums[j];
			dp[i][j] = max(sum, dp[i][j]);
		}
	}
}

分割等和子集

背包问题变形，背包问题解析文章。

//初始态
vector<bool> dp(sum,false);
dp[0] = true;
//状态的转换
for(int i = 0; i < num.size(); ++i)
{
	for(int j = sum; j >= num[i]; ++j)
	{
		dp[j] = dp[j]||dp[j-num[i]];
	}
}

奇怪的打印机

理解题目：举例来说，打印abcabc时的最少打印次数为5次，对应的最优解可以为：

1. aaaa->abaa->abca->abcab->abcabc，即先打印出来第0和第3位置的a;
2. a->abbbb->abcbb->abcab->abcabc，即先打印出来第1和第4位置的b;
3. a->ab->abcccc->abcacc->abcabc，即先打印出来第2和第5位置的c;

使用动态规划递推 s[i,j]表示s中第i个字母到第j个字母这个子串
dp[i,j]表示子串s[i,j]的最少打印次数，下面仅考虑dp[i,j]的计算方法 ①
s[i]这个字母只需在一次中打印，且总可以在第一次打印（因为他是首字母，后续打印不需要覆盖到它）。因为最优解可能有多种，设最优解中包含s[i]的那次最短长度的打印为
P，结束点为k ②
P这次打印的结尾字符应该与首字母s[i]相同，即s[i]==s[k]（否则，不相同的部分都是多余的打印，只会使得总打印次数更多） ③
P这次打印最后一个字符s[k]应该只被打印一次，即s[i]，s[k]在同一次被打印，且仅在这次中被打印（否则，P这次打印不需要包含s[k]）
④
s[i,j]被分成两段，s[i,k]和s[k+1,j],最优打印法中的任何一次打印不会跨越这两段（因为分界点s[k]只被打印一次）。当然s[k]可能就是s[j]，这样实际就没有分段，打印P会打印整段s[i,j]
⑤ 在④中的两段上分别递推，就得到： dp[i,j] = min(dp[i,k] + dp[k+1,j])
对所以满足s[i]==s[k]的k求min ⑥ 由于s[i]s[k],可得：dp[i,k] ==
dp[i,k-1]（因为打印s[i,k-1]的方法只要在第一次把s[i]打印在所有字符上，就能应用在s[i,k]之上了）
于是可以得到新的公式，可以避免kj的情况： dp[i,j] = min(dp[i,k-1] + dp[k+1,j])
作者：wang-sun
链接：https://leetcode-cn.com/problems/strange-printer/solution/xi-hua-yi-xia-guan-fang-ti-jie-de-zheng-ming-by-wa/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

统计不同的回文子序列

定义 dp[x][i][j] 为子串 S[i…j] 拥有不同回文子字符串的答案，且 S[i] == S[j] == ‘a’+x。由于字符串只包含四个字符 a, b, c, d，因此 0 <= x < 4。dp 的公式如下：
如果 S[i] != ‘a’+x，则 dp[x][i][j] = dp[x][i+1][j]
如果 S[j] != ‘a’+x，则 dp[x][i][j] = dp[x][i][j-1]
如果 S[i] == S[j] == ‘a’+x，则 dp[x][i][j] = 2 + dp[0][i+1][j-1] + dp[1][i+1][j-1] + dp[2][i+1][j-1] + dp[3][i+1][j-1]。当第一个和最后一个字符相同时，我们需要计算子串 S[i+1][j-1] 中所有不同的回文（a、b、c、d 中的每一个）加上第一个和最后一个字符的两个回文。
作者：LeetCode
链接：https://leetcode-cn.com/problems/count-different-palindromic-subsequences/solution/tong-ji-bu-tong-hui-wen-zi-zi-fu-chuan-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

如何理解dp[x][i][j] = 2 + dp[0][i+1][j-1] + dp[1][i+1][j-1] + dp[2][i+1][j-1] + dp[3][i+1][j-1]？这里有两点需要理解：

1. dp[0][i+1][j-1] + dp[1][i+1][j-1] + dp[2][i+1][j-1] + dp[3][i+1][j-1]：这里就是用的嵌套，dp[i][j]必定是由dp[i+1,j-1]决定的。
2. 为什么要+2？如果s[i]==s[j],举例来说s[0,1,2,3]=“aaaa”,dp[1][2]=2即(a,aa),dp[0][3]=4=2+dp[1][2],即a,aa,aaa,aaaa。

//初始化，全为0
for(int i = length-2; i >= 0; --i){
	for(int j = i; j < length; ++j){
		for(int k = 0; k < 4; ++k){
			char ch = 'a' + k;
			if(ch != s[i])
				dp[k][i][j] = dp[k][i+1][j];
			else if(ch != s[j])
				dp[k][i][j] = dp[k][i][j-1];
			else{
				if(s[i] == ch){
					if(i == j)
						dp[k][i][j] = 1;
					else if(i == j-1)
						dp[k][i][j] = 2;
					else
						dp[k][i][j] = 2 + dp[0][i+1][j-1] + dp[1][i+1][j-1] + dp[2][i+1][j-1] + dp[3][i+1][j-1];
				}
			}
		}
	}
}

多边形三角划分的最低得分

状态方程为 d p [ i ] [ j ] = m i n { d p [ i ] [ m ] + d p [ m ] [ j ] + t r a n [ i ] ∗ t r a n [ m ] ∗ t r a n [ j ] }   f o r   m = i + 1 : j − 1 dp[i][j]=min\{dp[i][m]+dp[m][j]+tran[i]*tran[m]*tran[j]\}\space for \space m=i+1:j-1 dp[i][j]=min{dp[i][m]+dp[m][j]+tran[i]∗tran[m]∗tran[j]} for m=i+1:j−1