动态规划问题
动态规划
- 1. 不相交的线
- 2. 不同的子序列
- 3. 通配符匹配
- 4. 交错字符串
1. 不相交的线
1.题目链接：不相交的线
2.问题描述：
在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。
现在，可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足满足：
nums1[i] == nums2[j]，且绘制的直线不与任何其他连线（非水平线）相交。
请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。
以这种方法绘制线条，并返回可以绘制的最大连线数。
示例1：
输入：nums1 = [1,4,2], nums2 = [1,2,4]
输出：2
解释：可以画出两条不交叉的线，如下图所示。
但无法画出第三条不相交的直线，因为从 nums1[1]=4 到 nums2[2]=4 的直线将与从 nums1[2]=2 到
nums2[1]=2 的直线相交。
示例 2：
输入：nums1 = [2,5,1,2,5], nums2 = [10,5,2,1,5,2]
输出：3
示例 3：
输入：nums1 = [1,3,7,1,7,5], nums2 = [1,9,2,5,1]
输出：2
提示：
1 <= nums1.length, nums2.length <= 500
1 <= nums1[i], nums2[j] <= 2000
3.问题分析：要求nums1[i] == nums2[j]，且绘制的直线不与任何其他连线（非水平线）相交，我们将这些相同的数据取出来，可以看到它们刚好是两个数组中的最长公共子序列，所以这道题就是让求两个数组的最长公共子序列。假设从nums1[i]的首尾开始，然后遍历nums2[j]，如果有数据相同，那么就能确定有公共子序列；然后就有两种思路，第一种，如果碰到相同的i，j都进行++操作，然后继续遍历，这种遍历出来的具有局限性，当nums1是nums2的子序列时，遍历才正确，遍历中间某一步有一个不同的话，就会出错；所以应该将nums1中的数据每一个都与nums2数组进行遍历，具体遍历如下。
- 状态表示：dp[i][j] 表⽰： nums1的 [0, i] 区间以及nums2的 [0, j] 区间内的所有的⼦序列中，最⻓公共⼦序列的⻓度。
- 状态转移方程：1.如果nums1[i] = nums2[j]，那么最⻓公共⼦序列就在nums1的 [0, i - 1] 以及nums2的[0, j - 1]区间上找到⼀个最⻓的，然后再加上nums1[i] 即可。因此
dp[i][j] = dp[i - 1][j - 1] + 1。 2.如果nums1[i] != nums2[j]，那么最长公共子序列可以在nums1中的（0，i - 1）和nums2中的（0，j）或者在nums1中的（0，i ）和nums2中的（0，j - 1）中寻找最大值，因此dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])。 - 初始化：dp表全初始化为0即可。
- 填表顺序：要求i，j位置的dp，先要求i-1或j-1的dp，所以从上往下填写每⼀⾏，每⼀⾏从左往右。
- 返回值：根据状态表⽰得：返回 dp[m][n] 。
4.代码如下：
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][j - 1], dp[i - 1][j]);
}
}
return dp[m][n];
}
};
2. 不同的子序列
1.题目链接：不同的子序列
2.题目描述：
给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数，结果需要对 109 + 7 取模。
示例 1：
输入：s = “rabbbit”, t = “rabbit”
输出：3
解释： 如下所示, 有 3 种可以从 s 中得到 "rabbit"的方案。 rabbbit rabbbit rabbbit
示例 2：
输入：s = “babgbag”, t = “bag”
输出：5
解释： 如下所示, 有 5 种可以从 s 中得到 “bag” 的方案。
babgbag babgbag babgbag babgbag babgbag
提示：
1 <= s.length, t.length <= 1000
s 和 t 由英文字母组成
3.题目分析：两个字符串s和t，其中将t看作短串，将s看作长串，从s中寻找组成t的字符串，计算组成t字符串的次数。对于两个字符串来说可以选取s中的(0, i)区间和t中的(0，j)区间当做研究对象，所以可以定义状态表示：dp[i][j] 表示在字符串s的 [0, i] 区间内的所有⼦序列中，有多少个 t 字符串 [0,j] 区间内的⼦串。然后对符合的条件进行分析，如1.当s[i] = t[j]时，此时有两种情况，一是选择s[i]做结尾，s[i] = t[j]，这两个位置可以和前面的字符相结合，结合后的个数和结合前的个数是相等的，因此dp[i][j] = dp[i - 1][j - 1]，二是不选s[i]做结尾，那么就在s中的(0, i - 1)区间与t中的(0, j)区间中找有多少个t的子串，此时dp[i][j] = dp[i - 1][j]，所以dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]；2.当**s[i] != t[j]**时，那么就只能在s中的(0, i - 1)区间与t中的(0, j)区间中找有多少个t的子串，因此dp[i][j] = dp[i - 1][j]。最后就剩下一些细节需要处理。
- 状态表示：dp[i][j] 表示在字符串s的 [0, i] 区间内的所有⼦序列中，有多少个 t 字符串 [0,j] 区间内的⼦串。
- 状态转移方程：当s[i] = t[j]时，dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]；当s[i] != t[j]时，dp[i][j] = dp[i - 1][j]。结果需要对 109 + 7 取模。
- 初始化：当s为空时， t 的⼦串中有⼀个空串和它⼀样，因此初始化第⼀列全部为1。
- 填表顺序：从上往下，从左往右。
- 返回值：返回dp[m][n]。
4.代码如下：
class Solution
{
public:
const int MOD = 1e9 + 7;
int numDistinct(string s, string t)
{
int m = s.size(), n = t.size();
vector<vector<int>> dp(m + 1, vector<int>(n + 1));
for (int i = 0; i <= m; ++i)
dp[i][0] = 1;
for (int j = 1; j <= n; ++j)
{
for (int i = j; i <= m; ++i)
{
if (s[i - 1] == t[j - 1])
dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j]) % MOD;
else
dp[i][j] = dp[i - 1][j] % MOD;
}
}
return dp[m][n];
}
};
3. 通配符匹配
1.题目链接：通配符匹配
2.题目描述：
给你一个输入字符串 ( s ) 和一个字符模式 ( p ) ，请你实现一个支持 ‘?’ 和 ‘*’ 匹配规则的通配符匹配：
‘?’ 可以匹配任何单个字符。
‘*’ 可以匹配任意字符序列（包括空字符序列）。
判定匹配成功的充要条件是：字符模式必须能够 完全匹配 输入字符串（而不是部分匹配）。
示例 1：
输入：s = “aa”, p = “a”
输出：false
解释：“a” 无法匹配 “aa” 整个字符串。
示例 2：
输入：s = “aa”, p = ""
输出：true
解释：'’ 可以匹配任意字符串。
示例 3：
输入：s = “cb”, p = “?a”
输出：false
解释：‘?’ 可以匹配 ‘c’, 但第二个 ‘a’ 无法匹配 ‘b’。
提示：
0 <= s.length, p.length <= 2000
s 仅由小写英文字母组成
p 仅由小写英文字母、‘?’ 或 ‘*’ 组成
3.问题分析：这道题用p字符串来遍历s字符串，其中p中含有 ’ ? ’ 和 ’ * ’ ，‘?’ 可以匹配任何单个字符。‘*’ 可以匹配任意字符序列（包括空字符序列）,? 不能匹配空字符，所以可以将 ？当做一个万能字母，是需要占位的。
- 因为要对两个字符串进行分析，两个for循环可以将所有情况都遍历到，所以定义一个二维dp表，
dp[i][j] 表⽰： p 字符串 [0, j] 区间内的⼦串能否匹配字符串 s 的 [0, i] 区间内的⼦串。 - 状态转移方程：对符合条件的情况进行分析，其中有两大方向，一是当s[i] = p[j]或者p[i] = ‘?’，因为当s[i] = p[j]或者p[i] = '?'时，p[j]都能与s[i]进行匹配，然后只要s中0到 i - 1 与p中0到 j - 1 都匹配，那么s和p就可以匹配成功，因此当s[i] = p[j]或者p[i] = ‘?’，
dp[i][j] = dp[i - 1][j - 1]；二是当p[j] = '*‘时，这种情况需要单独分析，因为’*‘可以匹配0个或多个字符，对s[i]位置以及p[j]进行分析，如果 j 位置的’*'匹配s中的空串，那么只要p(0, j - 1)与s(0, i)匹配即可，如果匹配一个、两个、三个…呢？那么就是p(0, j - 1)与s(0, i - 1)、p(0, j - 1)与s(0, i - 2)、p(0, j - 1)与s(0, i - 3) 等等，所以这里需要一个for循环来确定s中的某一个位置(只能由后往前遍历)到p[j - 1]是否匹配。因此dp[i][j] = dp[i][j - 1] || dp[i - 1][j - 1] || dp[i - 2][j - 1] || dp[i - 3][j - 1]… 这个表达式可以化简一下，对于dp中的i来说，每个位置的i为（i，i，i - 1，i - 2，i - 3…），而j为（j，j - 1，j - 1，j - 1…）要是给所有的j都减1，那么会构成新的项j - 2，如果给所有的 i 都减1，那么不会构成新项如（i，i - 1，i - 2，i - 3，i - 4…）看如下两个表达式dp[i][j] = dp[i][j - 1] ||dp[i - 1][j - 1] || dp[i - 2][j - 1] || dp[i - 3][j - 1]......给所有的 i - 1，dp[i - 1][j] =dp[i - 1][j - 1] || dp[i - 2][j - 1] || dp[i - 3][j - 1] || dp[i - 4][j - 1]......，红色字体所标识的表达式是相等的，因此dp[i][j] = dp[i][j - 1] || dp[i - 1][j]。 - 初始化：因为求dp i，j 位置的值需要知道 dp 的 i - 1,j - 1位置，以防越界，可以增加一行，一列；增加一行一列后需要对新增的一行一列初始化，对于第一列来说，只有当s，p都为空，即只有dp[0][0] = true，对于第一行来说，s是空串，而只有当p为 ‘*’ 时，p才能匹配空串，dp值才为true，要是有一个不为’*'，那么之后的dp值为false。
- 填表顺序：从上到下，从左往右依次填写。
- 返回值：返回dp[m][n]的bool值即可。
4.代码如下：
lass Solution
{
public:
bool isMatch(string s, string p)
{
int m = s.size(), n = p.size();
vector<vector<bool>> dp(m + 1, vector<bool>(n + 1));
dp[0][0] = true; //初始化第一列
for (int j = 1; j <= n; ++j) //初始化第一行
{
if (p[j - 1] == '*')
dp[0][j] = true;
else
break;
}
for (int i = 1; i <= m; ++i)
{
for (int j = 1; j <= n; ++j)
{
if (s[i - 1] == p[j - 1] || p[j - 1] == '?')
dp[i][j] = dp[i - 1][j - 1];
if (p[j - 1] == '*') //因为新增一行一列，所以s,p对应的i,j应-1
{
for (int k = i; k >= 0; --k) //确定s中的某一个位置到p[j - 1]是否匹配
{
if (dp[k][j - 1])
{
dp[i][j] = true;
break;
}
}
}
}
}
return dp[m][n];
}
};
//化简后
class Solution
{
public:
bool isMatch(string s, string p)
{
int m = s.size(), n = p.size();
vector<vector<bool>> dp(m + 1, vector<bool>(n + 1));
dp[0][0] = true; //初始化第一列
for (int j = 1; j <= n; ++j) //初始化第一行
{
if (p[j - 1] == '*')
dp[0][j] = true;
else
break;
}
for (int i = 1; i <= m; ++i)
{
for (int j = 1; j <= n; ++j)
{
if (s[i - 1] == p[j - 1] || p[j - 1] == '?')
dp[i][j] = dp[i - 1][j - 1];
if (p[j - 1] == '*') //因为新增一行一列，所以s,p对应的i,j应-1
{
dp[i][j] = dp[i][j - 1] || dp[i - 1][j];
}
}
}
return dp[m][n];
}
};
4. 交错字符串
1.题目链接：交错字符串
2.题目描述：
给定三个字符串 s1、s2、s3，请你帮忙验证 s3 是否是由 s1 和 s2 交错 组成的。
两个字符串 s 和 t 交错 的定义与过程如下，其中每个字符串都会被分割成若干 非空 子字符串：
s = s1 + s2 + … + sn
t = t1 + t2 + … + tm
|n - m| <= 1 交错 是 s1 + t1 + s2 + t2 + s3 + t3 + … 或者 t1 + s1 + t2 + s2 + t3 + s3 + …
注意：a + b 意味着字符串 a 和 b 连接。
示例1：
输入：s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbcbcac”
输出：true
示例 2：
输入：s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbbaccc”
输出：false
示例 3：
输入：s1 = “”, s2 = “”, s3 = “”
输出：true
提示：
0 <= s1.length, s2.length <= 100
0 <= s3.length <= 200
s1、s2、和 s3 都由小写英文字母组成
3.题目分析：
- 状态表示：和上述几道类似，
dp[i][j] 表⽰字符串 s1 中 [1, i] 区间内的字符串以及 s2 中 [1, j] 区间内的字符串，能否拼接成s3中 [1, i + j] 区间内的字符串。 - 状态转移方程：题⽬中交错后的字符串为s1 + t1 + s2 + t2 + s3 + t3… ，看似⼀个 s ⼀个 t 。实际上 s1 能够拆分成更⼩的⼀个字符，进⽽可以细化成s1 + s2 +s3 + t1 + t2 + s4… 。也就是说，并不是前⼀个⽤了s 的⼦串，后⼀个必须要⽤t 的⼦串。1.当 s3[i + j] = s1[i] 的时候，说明交错后的字符串的最后⼀个字符和s1 的最后⼀个字符匹配了。那么整个字符串能否交错组成，变成：s1中[1, i - 1]区间上的字符串以及s2中[1, j]区间上的字符串，能够交错形成s3 中 [1, i + j - 1] 区间上的字符串，也就是 dp[i - 1][j] ，此时dp[i][j] = dp[i - 1][j] 。2.当 s3[i + j] = s2[j] 的时候，与第一种情况类似，只要s1中的[1,i]区间和s2中的[1, j - 1] 区间能拼接s3[1, i + j - 1] 即可，此时dp[i][j] = dp[i][j - 1]，所以状态转移方程为：
如果s1[i] = s3[i + j]，dp[i][j] = dp[i - 1][j]；如果s2[j] = s3[i + j]，dp[i][j] = dp[i][j - 1]。 - 初始化：因为求dp i，j 位置的值需要知道 dp 的 i - 1,j - 1位置，所以对第一行和第一列初始化即可；第一行表示s1为空串，所以只考虑s2即可，相反第一列表示s2为空串，所以只考虑s1即可。
- 填表顺序：从上到下，从左往右依次填写。
- 返回值：返回dp[m][n]的bool值即可。
4.代码如下：
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;
vector<vector<bool>> dp(m + 1, vector<bool>(n + 1));
dp[0][0] = true;
for (int i = 1; i <= m; ++i)
{
if (s1[i - 1] == s3[i - 1])
dp[i][0] = true;
else
break;
}
for (int j = 1; j <= n; ++j)
{
if (s2[j - 1] == s3[j - 1])
dp[0][j] = true;
else
break;
}
for (int i = 1; i <= m; ++i)
{
for (int j = 1; j <= n; ++j)
{
if (s1[i - 1] == s3[i + j - 1])
dp[i][j] = dp[i - 1][j];
if (s2[j - 1] == s3[i + j - 1])
dp[i][j] = dp[i][j] || dp[i][j - 1];
}
}
return dp[m][n];
}
};