【算法】动态规划：子序列问题、回文子串问题、两个数组的dp
目录
- 1、子序列问题
- 最长递增子序列
- 摆动序列
- 最长递增子序列的个数 *
- 最长数对链
- 最长定差子序列
- 最长的斐波那契子序列的长度
- 最长等差数列
- 等差数列划分 II - 子序列 *
- 2、回文子串问题
- 回文子串
- 最长回文子串
- 分割回文串 IV
- 分割回文串 II *
- 最长回文子序列
- 让字符串成为回文串的最少插入次数
- 3、两个数组的dp
- 最长公共子序列
- 不相交的线
- 不同的子序列
- 通配符匹配 *
- 正则表达式匹配
- 交错字符串
- 两个字符串的最小ASCII删除和
- 最长重复子数组
1、子序列问题
子序列vs子数组：
- 子序列：不连续，顺序不变，适合动态规划问题；
- 子数组：连续，顺序不变，适合滑动窗口或 Kadane 算法。
最长递增子序列
- 最长递增子序列
dp[i] 表示以i位置的元素为 开头 的所有子序列中，最长递增子序列的长度。
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
int n = nums.size(), ret = 0;;
vector<int> dp(n, 1);
for (int i = n - 1; i >= 0; i--)
{
for (int j = i + 1; j < n; j++)
{
if (nums[j] > nums[i])
dp[i] = max(dp[i], dp[j] + 1);
}
ret = max(ret, dp[i]);
}
return ret;
}
};
dp[i] 表示以i位置的元素为 结尾 的所有子序列中，最长递增子序列的长度。
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
int n = nums.size(), ret = 1;
vector<int> dp(n, 1);
for (int i = 1; i < n; i++)
{
for (int j = 0; j < i; j++)
if (nums[i] > nums[j])
dp[i] = max(dp[i], dp[j] + 1);
ret = max(ret, dp[i]);
}
return ret;
}
};
摆动序列
- 摆动序列
定义状态表示：f[i] 为以i位置元素为结尾的所有子序列中，最后呈 “上升” 状态的最长子序列的长度；g[i] 为以i位置元素为结尾的所有子序列中，最后呈 “下降” 状态的最长子序列的长度。
固定某个位置为i，让j在[0, i-1]中搜索，当nums[j]>nums[i]时呈现下降状态，则g[i] = max(f[j] + 1, g[i])。
class Solution {
public:
int wiggleMaxLength(vector<int>& nums) {
int n = nums.size();
vector<int> f(n, 1), g(n, 1);
int ret = 1;
for (int i = 1; i < n; i++)
{
for (int j = 0; j < i; j++)
{
if (nums[i] > nums[j]) f[i] = max(g[j] + 1, f[i]);
else if (nums[i] < nums[j]) g[i] = max(f[j] + 1, g[i]);
}
ret = max(ret, max(f[i], g[i]));
}
return ret;
}
};
最长递增子序列的个数 *
- 最长递增子序列的个数
定义状态 len[i] 为以i位置元素为结尾的最长递增子序列的长度，count[i] 为以i位置元素为结尾的最长子序列出现的个数。
统计出i位置的len[i]和count[i]后，如果最长长度不变，则增加之前的技术；如果变长，则刷新最长子序列出现的个数；如果变短，则不用处理。
class Solution {
public:
int findNumberOfLIS(vector<int>& nums) {
int n = nums.size();
vector<int> len(n, 1), count(n, 1);
int retlen = 1, retcount = 1;
for (int i = 1; i < n; i++)
{
for (int j = 0; j < i; j++)
{
if (nums[j] < nums[i])
{
if (len[i] == len[j] + 1) count[i] += count[j];
else if (len[i] < len[j] + 1)
{
count[i] = count[j];
len[i] = len[j] + 1;
}
}
}
if (retlen == len[i]) retcount += count[i];
else if (retlen < len[i])
{
retlen = len[i];
retcount = count[i];
}
}
return retcount;
}
};
最长数对链
- 最长数对链
定义状态 dp[i] 表示以i位置元素为结尾的所有数对列中的最长长度，对于dp[i] ，遍历所有[0, i - 1] 区间内数对用j 表示下标，找出所有满足pairs[j][1] < pairs[i][0] 的j ，找出其中最大的dp[j] ，然后加上1 ，就是以i 位置为结尾的最长数对链。
class Solution {
public:
int findLongestChain(vector<vector<int>>& pairs) {
sort(pairs.begin(), pairs.end());
int n = pairs.size();
vector<int> dp(n, 1);
int ret = 1;
for (int i = 1; i < n; i++)
{
for (int j = 0; j < i; j++)
{
if (pairs[j][1] < pairs[i][0])
dp[i] = max(dp[j] + 1, dp[i]);
}
ret = max(ret, dp[i]);
}
return ret;
}
};
最长定差子序列
- 最长定差子序列
定义状态 dp[i] 表示以i 位置的元素为结尾所有的子序列中，最长的等差子序列的长度。
对于dp[i] ，上一个定差子序列的取值定为arr[i] - difference 。只要找到以上一个数
字为结尾的定差子序列长度的dp[arr[i] - difference] ，然后加上1 ，就是以i 为结尾的定差子序列的长度。因此，这里可以选择使用哈希表做优化。我们可以把「元素， dp[j] 」绑定，放进哈希表中。甚至不用创建dp 数组，直接在哈希表中做动态规划。
class Solution {
public:
int longestSubsequence(vector<int>& arr, int d) {
unordered_map<int, int> hash;
hash[arr[0]] = 1;
int ret = 1;
for (int i = 1; i < arr.size(); i++)
{
hash[arr[i]] = hash[arr[i] - d] + 1;
ret = max(ret, hash[arr[i]]);
}
return ret;
}
};
最长的斐波那契子序列的长度
- 最长的斐波那契子序列的长度
定义状态 dp[i][j] 表示以i、j位置元素为结尾的所有子序列中，最长的斐波那契子序列的长度。
则构成斐波那契序列的条件为：arr[j] - arr[i] 的值在数组中存在，并且其位置在j前面。
class Solution {
public:
int lenLongestFibSubseq(vector<int>& arr) {
int n = arr.size();
unordered_map<int, int> hash;
// 将元素和其下标绑定
for (int i = 0; i < n; i++) hash[arr[i]] = i;
vector<vector<int>> dp(n, vector<int>(n, 2));
int ret = 2;
for (int i = 2; i < n; i++)
{
for (int j = 1; j < i; j++)
{
int k = arr[i] - arr[j];
if (k < arr[j] && hash.count(k))
dp[j][i] = dp[hash[k]][j] + 1;
ret = max(ret, dp[j][i]);
}
}
return ret < 3 ? 0 : ret;
}
};
最长等差数列
- 最长等差数列
定义状态 dp[i][j] 表示以i、j位置为结尾的所有子序列中，最长等差子序列的长度。
用哈希表，一遍遍历一遍填表，可以节省时间。
class Solution {
public:
int longestArithSeqLength(vector<int>& nums) {
int n = nums.size();
unordered_map<int, int> hash;
hash[nums[0]] = 0;
vector<vector<int>> dp(n, vector<int>(n, 2));
int ret = 2;
for (int i = 1; i < n; i++) // 固定倒数第二个位置
{
for (int j = i + 1; j < n; j++) // 枚举最后一个位置
{
int a = 2 * nums[i] - nums[j];
if (hash.count(a))
dp[i][j] = dp[hash[a]][i] + 1;
ret = max(ret, dp[i][j]);
}
hash[nums[i]] = i;
}
return ret;
}
};
等差数列划分 II - 子序列 *
- 等差数列划分 II - 子序列
定义状态 dp[i][j] 表示以i、j位置元素为结尾的所有组序列中，等差子序列的个数。
之所以用两个维度进行状态表示，是因为等差子序列我们需要知道其中的两个元素才能推出第三个元素。
class Solution {
public:
int numberOfArithmeticSlices(vector<int>& nums) {
int n = nums.size();
unordered_map<long, vector<int>> hash;
for (int i = 0; i < n; i++) hash[nums[i]].push_back(i);
vector<vector<int>> dp(n, vector<int>(n));
int ret = 0;
for (int i = 2; i < n; i++)
{
for (int j = 1; j < i; j++)
{
long k = (long)2 * nums[j] - nums[i];
for (int e : hash[k])
{
if (e < j) dp[j][i] += dp[e][j] + 1;
}
ret += dp[j][i];
}
}
return ret;
}
};
2、回文子串问题
回文子串
- 回文子串
定义 dp[i][j] 表示 [i, j] 区间内的字符串是否是回文子串，i <= j，要特别注意填表顺序。
class Solution {
public:
int countSubstrings(string s) {
int n = s.size();
vector<vector<bool>> dp(n, vector<bool>(n));
int ret = 0;
for (int i = n - 1; i >= 0; i--)
{
for (int j = i; j < n; j++)
{
if (s[i] == s[j])
dp[i][j] = i + 1 < j ? dp[i + 1][j - 1] : true;
if (dp[i][j]) ret++;
}
}
return ret;
}
};
最长回文子串
- 最长回文子串
一边填dp表，一边统计最长的回文子串。
class Solution {
public:
string longestPalindrome(string s) {
int n = s.size();
vector<vector<bool>> dp(n, vector<bool>(n));
int begin = 0, len = 1;
for (int i = n - 1; i >= 0; i--)
for (int j = i; j < n; j++)
{
if (s[i] == s[j]) dp[i][j] = i + 1 < j ? dp[i + 1][j - 1] : true;
if (dp[i][j] && j - i + 1 > len)
{
len = j - i + 1;
begin = i;
}
}
return s.substr(begin, len);
}
};
分割回文串 IV
- 分割回文串 IV
class Solution {
public:
bool checkPartitioning(string s) {
int n = s.size();
vector<vector<bool>> dp(n, vector<bool>(n));
for (int i = n - 1; i >= 0; i--)
for (int j = i; j < n; j++)
if (s[i] == s[j]) dp[i][j] = i + 1 < j ? dp[i + 1][j - 1] : true;
for (int i = 0; i < n - 1; i++)
for (int j = 0; j < n - 1; j++)
if (dp[0][i] && dp[i + 1][j] && dp[j + 1][n - 1])
return true;
return false;
}
};
分割回文串 II *
- 分割回文串 II
定义状态 dp[i] 表示0-i区间符合要求的最少分割次数。
如果 j - i 是回文子串，则 dp[i] = dp[j - 1] + 1；后面的+1表示分割一次。
class Solution {
public:
int minCut(string s) {
int n = s.size();
vector<vector<bool>> isPal(n, vector<bool>(n));
for (int i = n - 1; i >= 0; i--)
for (int j = i; j < n; j++)
if (s[i] == s[j]) isPal[i][j] = i + 1 < j ? isPal[i + 1][j - 1] : true;
vector<int> dp(n, INT_MAX);
for (int i = 0; i < n; i++)
{
if (isPal[0][i]) dp[i] = 0;
else
{
for (int j = 1; j <= i; j++)
if (isPal[j][i])
dp[i] = min(dp[j - 1] + 1, dp[i]);
}
}
return dp[n - 1];
}
};
最长回文子序列
- 最长回文子序列
定义状态 dp[i][j] 表示区间 i到j 范围内的所有子序列中，最长回文子序列的长度。
当首尾两个元素「相同」的时候，也就是s[i] == s[j] ：那么[i, j] 区间上的最长回文子序列，应该是[i + 1, j - 1] 区间内的那个最长回文子序列首尾填上s[i] 和s[j] ，此时dp[i][j] = dp[i + 1][j - 1] + 2.
当 s[i] != s[j] 时： dp[i][j] = max(dp[i][j - 1], dp[i + 1][j])。
class Solution {
public:
int longestPalindromeSubseq(string s) {
int n = s.size();
vector<vector<int>> dp(n, vector<int>(n));
for (int i = n - 1; i >= 0; i--)
{
dp[i][i] = 1;
for (int j = i + 1; j < n; j++)
{
if (s[i] == s[j]) dp[i][j] = dp[i + 1][j - 1] + 2;
else dp[i][j] = max(dp[i][j - 1], dp[i + 1][j]);
}
}
return dp[0][n - 1];
}
};
让字符串成为回文串的最少插入次数
- 让字符串成为回文串的最少插入次数
定义状态 dp[i][j] 表示让i到j区间称为回文串的最小插入次数。
i == j 时不用考虑，在初始化dp表的时候其中的值默认为0，所以直接在 j = i + 1 处开始遍历；i + 1 == j 可以放在 i + 1 < j 中，因为 dp[i + 1][j - 1] 访问的是 i + 1 == j 的左下角，这个位置刚好用不到，默认也为0。
当 s[i] != s[j] 时，我们假定在i的左边插入一个s[j]，或在j的右边插入一个s[i]，然后就可以在 dp[i][j - 1] 或 dp[i + 1][j] 中找最小操作次数。
class Solution {
public:
int minInsertions(string s) {
int n = s.size();
vector<vector<int>> dp(n, vector<int>(n));
for (int i = n - 1; i >= 0; i--)
{
for (int j = i + 1; j < n; j++)
if (s[i] == s[j]) dp[i][j] = dp[i + 1][j - 1];
else dp[i][j] = min(dp[i + 1][j], dp[i][j - 1]) + 1;
}
return dp[0][n - 1];
}
};
3、两个数组的dp
最长公共子序列
- 最长公共子序列
定义状态 dp[i][j] 为s1的[0, i]区间和s2的[0, j]区间中所有的子序列中，最长公共子序列的长度。
class Solution {
public:
int longestCommonSubsequence(string text1, string text2) {
int m = text1.size(), n = text2.size();
vector<vector<int>> dp(m + 1, vector<int>(n + 1));
for (int i = 1; i <= m; i++)
{
for (int j = 1; j <= n; j++)
{
if (text1[i-1] == text2[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
else dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
}
}
return dp[m][n];
}
};
不相交的线
- 不相交的线
说白了我白说了，这就是 “最长公共子序列”。
我是程序猿，我可以作证，代码一模一样。
class Solution {
public:
int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
int m = nums1.size(), n = nums2.size();
vector<vector<int>> dp(m + 1, vector<int>(n + 1));
for (int i = 1; i <= m; i++)
{
for (int j = 1; j <= n; j++)
{
if (nums1[i-1] == nums2[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
else dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
}
}
return dp[m][n];
}
};
不同的子序列
- 不同的子序列
dp[i][j]表示s的[0, j]区间中所有的子序列中有多少个t的[0, j]区间的子串。
class Solution {
public:
int numDistinct(string s, string t) {
const int mod = 1e9 + 7;
int m = t.size(), n = s.size();
vector<vector<int>> dp(m + 1, vector<int>(n + 1));
for (int i = 0; i < n; i++) dp[0][i] = 1;
for (int i = 1; i <= m; i++)
{
for (int j = 1; j <= n; j++)
{
dp[i][j] = dp[i][j - 1];
if (s[j - 1] == t[i - 1])
dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % mod;
}
}
return dp[m][n];
}
};
通配符匹配 *
- 通配符匹配
dp[i][j] 表示 p[0, j] 内的子串能否匹配 s[0, i] 内的子串。
class Solution {
public:
bool isMatch(string s, string p) {
int m = s.size(), n = p.size();
// 对应下标
s = ' ' + s;
p = ' ' + p;
vector<vector<bool>> dp(m + 1, vector<bool>(n + 1));
// 初始化空串的情况
dp[0][0] = true;
for (int i = 1; i <= n; i++)
if (p[i] == '*') dp[0][i] = true;
else break;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
if (p[j] == '*') dp[i][j] = dp[i - 1][j] || dp[i][j - 1];
else dp[i][j] = (p[j] == '?' || s[i] == p[j]) && dp[i - 1][j - 1];
return dp[m][n];
}
};
正则表达式匹配
- 正则表达式匹配
定义状态 dp[i][j] 表示 p[0, j] 区间内的子串能否匹配 s[0, i] 区间内的子串。
class Solution {
public:
bool isMatch(string s, string p) {
int m = s.size(), n = p.size();
// 对应下标
s = ' ' + s;
p = ' ' + p;
vector<vector<bool>> dp(m + 1, vector<bool>(n + 1));
// 初始化空串的情况
dp[0][0] = true;
for (int i = 2; i <= n; i += 2)
if (p[i] == '*') dp[0][i] = true;
else break;
for (int i = 1; i <= m; i++)
{
for (int j = 1; j <= n; j++)
{
if (p[j] == '*')
dp[i][j] = dp[i][j-2] || ((s[i] == p[j-1] || p[j-1] == '.') && dp[i-1][j]);
else
dp[i][j] = (s[i] == p[j] || p[j] == '.') && dp[i-1][j-1];
}
}
return dp[m][n];
}
};
交错字符串
- 交错字符串
定义状态 dp[i, j] 表示 s1[0, i] 区间内的字符串和 s2[0, j] 区间内的字符串能否拼接成 s3[0, i + j] 区间内的字符串。
class Solution {
public:
bool isInterleave(string s1, string s2, string s3) {
int m = s1.size(), n = s2.size();
if (m + n != s3.size()) return false;
s1 = ' ' + s1, s2 = ' ' + s2, s3 = ' ' + s3;
vector<vector<bool>> dp(m + 1, vector<bool>(n + 1));
dp[0][0] = true;
for (int i = 1; i <= n; i++)
if (s2[i] == s3[i]) dp[0][i] = true;
else break;
for (int i = 0; i <= m; i++)
if (s1[i] == s3[i]) dp[i][0] = true;
else break;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
dp[i][j] = (s1[i] == s3[i + j] && dp[i - 1][j])
|| (s2[j] == s3[i + j] && dp[i][j - 1]);
return dp[m][n];
}
};
两个字符串的最小ASCII删除和
- 两个字符串的最小ASCII删除和
实际就是求两个字符串的最长公共子序列的ASCII码和。
定义状态 dp[i][j] 表示s1[0, i]区间和s2[0, j]区间内的所有子序列中，最长公共子序列的ASCII码和。
对于初始化dp表，当s1为空串或s2为空串时，dp[0][i] 和 dp[j][0] 都为0。
class Solution {
public:
int minimumDeleteSum(string s1, string s2) {
int m = s1.size(), n = s2.size();
vector<vector<int>> dp(m + 1, vector<int>(n + 1));
for (int i = 1; i <= m; i++)
{
for (int j = 1; j <= n; j++)
{
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
if (s1[i - 1] == s2[j - 1])
dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + s1[i - 1]);
}
}
int sum = 0;
for (char ch : s1) sum += ch;
for (char ch : s2) sum += ch;
return sum - dp[m][n] - dp[m][n];
}
};
最长重复子数组
- 最长重复子数组
class Solution {
public:
int findLength(vector<int>& nums1, vector<int>& nums2) {
int m = nums1.size(), n = nums2.size();
vector<vector<int>> dp(m + 1, vector<int>(n + 1));
int ret = 0;
for (int i = 1; i <= m; i++)
{
for (int j = 1; j <= n; j++)
{
if (nums1[i - 1] == nums2[j - 1])
dp[i][j] = dp[i - 1][j - 1] + 1;
ret = max(ret, dp[i][j]);
}
}
return ret;
}
};
本篇文章的分享就到这里了，如果您觉得在本文有所收获，还请留下您的三连支持哦~
