【动态规划】【字符串】扰乱字符串

作者推荐

视频算法专题

涉及知识点

动态规划 字符串

LeetCode87扰乱字符串

使用下面描述的算法可以扰乱字符串 s 得到字符串 t ：
如果字符串的长度为 1 ，算法停止
如果字符串的长度 > 1 ，执行下述步骤：
在一个随机下标处将字符串分割成两个非空的子字符串。即，如果已知字符串 s ，则可以将其分成两个子字符串 x 和 y ，且满足 s = x + y 。
随机 决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即，在执行这一步骤之后，s 可能是 s = x + y 或者 s = y + x 。
在 x 和 y 这两个子字符串上继续从步骤 1 开始递归执行此算法。
给你两个 长度相等 的字符串 s1 和 s2，判断 s2 是否是 s1 的扰乱字符串。如果是，返回 true ；否则，返回 false 。
示例 1：
输入：s1 = “great”, s2 = “rgeat”
输出：true
解释：s1 上可能发生的一种情形是：
“great” --> “gr/eat” // 在一个随机下标处分割得到两个子字符串
“gr/eat” --> “gr/eat” // 随机决定：「保持这两个子字符串的顺序不变」
“gr/eat” --> “g/r / e/at” // 在子字符串上递归执行此算法。两个子字符串分别在随机下标处进行一轮分割
“g/r / e/at” --> “r/g / e/at” // 随机决定：第一组「交换两个子字符串」，第二组「保持这两个子字符串的顺序不变」
“r/g / e/at” --> “r/g / e/ a/t” // 继续递归执行此算法，将 “at” 分割得到 “a/t”
“r/g / e/ a/t” --> “r/g / e/ a/t” // 随机决定：「保持这两个子字符串的顺序不变」
算法终止，结果字符串和 s2 相同，都是 “rgeat”
这是一种能够扰乱 s1 得到 s2 的情形，可以认为 s2 是 s1 的扰乱字符串，返回 true
示例 2：
输入：s1 = “abcde”, s2 = “caebd”
输出：false
示例 3：
输入：s1 = “a”, s2 = “a”
输出：true
参数：
s1.length == s2.length
1 <= s1.length <= 30
s1 和 s2 由小写英文字母组成

动态规划

时间复杂度😮(n⁴) ，状态数n ^ 3^,每个状态的转移时间复杂度O(n)。

动态规划的状态表示	len,i,j分别表示字串的长度,在s1和s2的起始位置
动态规划的转移方程	下文详细列出
动态规划的初始状态	全为false
动态规划的填表顺序	len,i,j全部从小到大。由短到长处理子字符串,确保动态规划的无后效性
动态规划的返回值	dp[n]p0][0]

代码

核心代码

template<class T>
void AssignVector3(vector<vector<vector<T>>>& v, int len1, int len2, int len3, T tDefault)
{
	v.assign(len1, vector<vector<T>>(len2, vector<T>(len3, tDefault)));
}

class Solution {
public:
	bool isScramble(string s1, string s2) {
		m_c = s1.length();
		vector < vector<vector<bool>>> dp;
		AssignVector3(dp, m_c + 1, m_c, m_c, false);
		for (int len = 1; len <= m_c; len++)
		{
			for (int i = 0; i + len <= m_c; i++)
			{
				for (int j = 0; j + len <= m_c; j++)
				{
					if (1 == len)
					{
						dp[len][i][j] = (s1[i] == s2[j]);
					}
					for (int k = 1; k < len; k++)
					{
						//交换 和 不交换
						bool b = (dp[k][i][j + len - k] && dp[len - k][i + k][j]) || (dp[k][i][j] && dp[len - k][i + k][j+k]);
						dp[len][i][j] = dp[len][i][j] || b;
					}
				}
			}
		}
		return dp[m_c][0][0];
	}
	int m_c;
};

测试用例

template<class T>
void Assert(const T& t1, const T& t2)
{
	assert(t1 == t2);
}

template<class T>
void Assert(const vector<T>& v1, const vector<T>& v2)
{
	if (v1.size() != v2.size())
	{
		assert(false);
		return;
	}
	for (int i = 0; i < v1.size(); i++)
	{
		Assert(v1[i], v2[i]);
	}
}


int main()
{
	string s1,s2;	
	{
		Solution sln;
		s1 = "great", s2 = "rgeat";
		auto res = sln.isScramble(s1, s2);
		Assert(true, res);
	}
	{
		Solution sln;
		s1 = "abcde", s2 = "caebd";
		auto res = sln.isScramble(s1, s2);
		Assert(false, res);
	}
	{
		Solution sln;
		s1 = "a", s2 = "a";
		auto res = sln.isScramble(s1, s2);
		Assert(true, res);
	}
	

}

2022年12月版

class Solution {
public:
bool isScramble(string s1, string s2) {
bool dp[31][30][30] = { false };
for (int i = 0; i < s1.length(); i++)
{
for (int j = 0; j < s2.length(); j++)
{
dp[1][i][j] = s1[i] == s2[j];
}
}
for (int len = 2; len <= s1.length(); len++)
{
for (int i = 0; i+len-1 < s1.length(); i++)
{
for (int j = 0; j + len - 1 < s2.length(); j++)
{
bool b = false;
for (int m = 1; m < len; m++)
{
if (dp[m][i][j] && dp[len - m][i + m][j + m])
{
b = true;
}
if (dp[m][i][j + len - m] && dp[len - m][i + m][j])
{
b = true;
}
}
dp[len][i][j] = b;
}
}
}
return dp[s1.length()][0][0];
}
};

2023年6月版

class Solution {
public:
bool isScramble(string s1, string s2) {
m_c = s1.length();
vector < vector<vector>> vLenBegin1Begin2(m_c + 1, vector<vector>(m_c, vector(m_c,true)));
for (int b1 = 0; b1 < m_c; b1++)
{
for (int b2 = 0; b2 < m_c; b2++)
{
vLenBegin1Begin2[1][b1][b2] = s1[b1] == s2[b2];
}
}
for (int len = 2; len <= m_c; len++)
{
for (int b1 = 0; b1 + len - 1 < m_c; b1++)
{
for (int b2 = 0; b2 + len - 1 < m_c; b2++)
{
bool bSame = false;
for (int leftLen = 1; leftLen < len; leftLen++)
{
const int iRightLen = len - leftLen;
//不改变位置
const int tmp = vLenBegin1Begin2[leftLen][b1][b2] && vLenBegin1Begin2[len - leftLen][b1 + leftLen][b2 + leftLen];
bSame |= tmp;
//改变位置
const int tmp2 = vLenBegin1Begin2[leftLen][b1][b2 + iRightLen] && vLenBegin1Begin2[iRightLen][b1 + leftLen][b2];
bSame |= tmp2;
}
vLenBegin1Begin2[len][b1][b2] = bSame;
}
}
}
return vLenBegin1Begin2.back()[0][0];
}
int m_c;
};

扩展阅读

视频课程

有效学习：明确的目标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快

速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

相关

下载

想高屋建瓴的学习算法，请下载《喜缺全书算法册》doc版
https://download.csdn.net/download/he_zhidan/88348653

我想对大家说的话
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

操作系统：win7 开发环境： VS2019 C++17
或者 操作系统：win10 开发环境： VS2022 C++17
如无特殊说明，本算法用**C++**实现。