一、题目打卡
1.1 最长公共子序列
题目链接:. - 力扣(LeetCode)
class Solution {
public:
int longestCommonSubsequence(string text1, string text2) {
vector<vector<int>> dp(text1.size(), vector<int>(text2.size(), 0));
for(int i = 0 ; i < text1.size(); i++){
// if(text1[i] == text2[0]) dp[i][0] = 1;
if(text1[i] == text2[0]){
while(i < text1.size()){
dp[i][0] = 1;
i++;
}
}
}
for(int i = 0 ; i < text2.size(); i++){
// if(text2[i] == text1[0]) dp[0][i] = 1;
if(text2[i] == text1[0]){
while(i < text2.size()){
dp[0][i] = 1;
i++;
}
}
}
// for(int i = 0 ; i < text1.size();i++){
// for(int j = 0 ;j < text2.size();j++){
// cout << dp[i][j];
// }
// cout << endl;
// }
// cout << "---------------" << endl;
for(int i = 1 ; i < text1.size();i++){
for(int j = 1 ; j < text2.size();j++){
if(text1[i] == text2[j]) dp[i][j] = dp[i - 1][j - 1] + 1;
else dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
}
}
// for(int i = 0 ; i < text1.size();i++){
// for(int j = 0 ;j < text2.size();j++){
// cout << dp[i][j];
// }
// cout << endl;
// }
return dp[text1.size() - 1][text2.size() - 1];
}
};
做这个题目的时候,我想到了之前做的最大递增子序列那个题目,这样来看的前提下,这个题目就会形成一个四层循环(因为最后两层需要去找到前面dp数组数值最大的位置),但是我看了一眼答案发现并没有这样,于是引起了思考,思考的结果是,由于这个题目存在两个方面的区别,首先是递增子序列那个题目,需要去检索的是在前面的序列中,比当前值要小的组合,但是这个题目不存在找这个,并且我发现这个题目搜索的过程中是一个二维的数组,也就是是两个数组之间的对比,和之前那个一维数组不太一样,这样的情况下,状态转移就可以来自上面,左边和左上角,也就是这个存在继承的关系,但是之前的递增子序列不存在,因为本身数组是无序的,继承之前的数的前提是必须当前值要比前面的值都要大,但是这个是数组的比较,只存在相等与否,所以不存在这个问题。
然后做的过程中发现一个问题就是,这个题目的初始化也有一定的考究,考虑到我上面说的那个继承的情况,所以初始化的方式和之前不一样,这样的情况下,如果为了简化这个初始化的过程,其实可以给dp数组增加一个维度:
class Solution {
public:
int longestCommonSubsequence(string text1, string text2) {
vector<vector<int>> dp(text1.size() + 1, vector<int>(text2.size() + 1, 0));
for (int i = 1; i <= text1.size(); i++) {
for (int j = 1; j <= text2.size(); 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[text1.size()][text2.size()];
}
};
1.2 不想交的线
题目链接:. - 力扣(LeetCode)
class Solution {
public:
int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
vector<vector<int>> dp(nums1.size() + 1, vector<int>(nums2.size() + 1, 0));
for(int i = 1 ; i < nums1.size() + 1; i++){
for(int j = 1 ; j < nums2.size() + 1; 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]);
}
}
// for(int i = 0 ; i < nums1.size() + 1;i++){
// for(int j = 0 ; j < nums2.size() + 1; j++){
// cout << dp[i][j] << " ";
// }
// cout << endl;
// }
return dp[nums1.size()][nums2.size()];
}
};
这个题目和上面的那个题目是一样的,也就算是上面那个题目的一个实际的使用的描述形式。写的时候需要注意,如果是这种不需要初始化的情况,那么在进行nums1和nums2的比较的时候,就需要对索引进行减 1 的操作。
1.3 最大子数组和
题目链接:. - 力扣(LeetCode)
class Solution {
public:
int maxSubArray(vector<int>& nums) {
vector<int> dp(nums.size(), 0);
dp[0] = nums[0];
int res = dp[0];
for(int i = 1 ; i < nums.size();i++){
// if(nums[i] > nums[i - 1]) dp[i] = dp[i - 1] + nums[i];
// else dp[i] = nums[i];
// if(dp[i - 1] + nums[i] > dp[i - 1]) dp[i] = max(dp[i - 1] + nums[i], nums[i]);
// if(nums[i] + dp[i - 1] > 0) dp[i] = max(dp[i - 1] + nums[i], nums[i]); // 如果前面积累的还没有当前的数字大,那就直接以当前的值作为初值
if( dp[i - 1] > 0) dp[i] = dp[i - 1] + nums[i]; // 如果前面积累的还没有当前的数字大,那就直接以当前的值作为初值
else dp[i] = nums[i];
res = max(dp[i], res);
}
// for(auto & it : dp){
// cout << it << " ";
// }
// cout << endl;
return res;
}
};
这个主要思路是理解清楚状态的定义,从 0 到 i 的所得到的连续子数组的最大和,这样的就可以看出,状态转移就会分为两个情况,如果之前的状态是正数,那么这一轮就可以继续进行累加,如果是dp数组的状态是负数了,那么就重置然后重新开始累加。
或者是按照这种理解也是可以的:
class Solution {
public:
int maxSubArray(vector<int>& nums) {
if (nums.size() == 0) return 0;
vector<int> dp(nums.size());
dp[0] = nums[0];
int result = dp[0];
for (int i = 1; i < nums.size(); i++) {
dp[i] = max(dp[i - 1] + nums[i], nums[i]); // 状态转移公式
if (dp[i] > result) result = dp[i]; // result 保存dp[i]的最大值
}
return result;
}
};
这样道理其实是一样的,这样比大,其实是为了排除掉dp数组的前一项为负数的情况,因为这样继续累加肯定会导致数值变小。