考虑到一般动态规划的写法是n方,为了降低复杂度,考虑每次假如选择当前数dp[i]对应最长的序列,就找前面上一个数(已经做递推的时候记录了上一个数的比他小的一个数,因为等于上一个比他小的数的序列长度(已经最大)加1,所以不一定是离当前数的比他小的最近的数)
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
int len=nums.size();
vector<int> nextp(len+1,0);
vector<int> dp(len+1,1);
if(nums.size()==0) return 0;
dp[0]=1;
nextp[0]=-1;
for(int i=1;i<len;i++){
nextp[i]=i-1;
}
for(int i=1;i<len;i++){
for(int j=nextp[i];j!=-1;){
if(nums[i]>nums[j])
{dp[i]=max(dp[j]+1,dp[i]);
nextp[i]=j;
// cout<<" >"<<i<<" "<<j<<endl;
break;
}
else{
dp[i]=max(dp[i],1);
j=nextp[j];
// cout<<" <="<<i<<" "<<j<<endl;
}
}
}
return dp[len-1];
}
};
题解其实是一般的n方动态规划写法。
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
int len=nums.size();
vector<int> dp(len+1,1);
if(nums.size()==0) return 0;
int res=0;
for(int i=1;i<len;i++){
for(int j=0;j<i;j++){
if(nums[i]>nums[j])
{
dp[i]=max(dp[i],dp[j]+1);
}
}
res=max(res,dp[i]);
}
return res;
}
};
一遍过
class Solution {
public:
int findLengthOfLCIS(vector<int>& nums) {
int len=nums.size();
vector<int> dp(len+1,1);
if(len==0) return 0;
int res=1;
for(int i=1;i<nums.size();i++){
if(nums[i]>nums[i-1])
{dp[i]=dp[i-1]+1;
res=max(res,dp[i]);
}
}
return res;
}
};
因为本题要求连续递增子序列,所以就只要比较nums[i]与nums[i - 1],而不用去比较nums[j]与nums[i] (j是在0到i之间遍历)。
既然不用j了,那么也不用两层for循环,本题一层for循环就行,比较nums[i] 和 nums[i - 1]。
贪心
这道题目也可以用贪心来做,也就是遇到nums[i] > nums[i - 1]的情况,count就++,否则count为1,记录count的最大值就可以了。
class Solution {
public:
int findLengthOfLCIS(vector<int>& nums) {
if (nums.size() == 0) return 0;
int result = 1; // 连续子序列最少也是1
int count = 1;
for (int i = 1; i < nums.size(); i++) {
if (nums[i] > nums[i - 1]) { // 连续记录
count++;
} else { // 不连续,count从头开始
count = 1;
}
if (count > result) result = count;
}
return result;
}
};
概括来说:不连续递增子序列的跟前0-i 个状态有关,连续递增的子序列只跟前一个状态有关
子数组是连续子序列。
看了题解。
- 确定dp数组(dp table)以及下标的含义
dp[i][j] :以下标i - 1为结尾的A,和以下标j - 1为结尾的B,最长重复子数组长度为dp[i][j]。 (特别注意: “以下标i - 1为结尾的A” 标明一定是 以A[i-1]为结尾的字符串 )
2、确定递推公式
根据dp[i][j]的定义,dp[i][j]的状态只能由dp[i - 1][j - 1]推导出来。
即当A[i - 1] 和B[j - 1]相等的时候,dp[i][j] = dp[i - 1][j - 1] + 1;
根据递推公式可以看出,遍历i 和 j 要从1开始!
其实就是两层for循环。
class Solution {
public:
int findLength(vector<int>& nums1, vector<int>& nums2) {
int len1=nums1.size();
int len2=nums2.size();
vector<vector<int>> dp(len1+1,vector<int>(len2+1,0));
int res=0;
for(int i=1;i<=len1;i++){
for(int j=1;j<=len2;j++){
if(nums1[i-1]==nums2[j-1]){
dp[i][j]=dp[i-1][j-1]+1;
res=max(res,dp[i][j]);
}
}
}
return res;
}
};
滚动数组版本:此时遍历B数组的时候,就要从后向前遍历,这样避免重复覆盖。
/ 版本二
class Solution {
public:
int findLength(vector<int>& A, vector<int>& B) {
vector<int> dp(vector<int>(B.size() + 1, 0));
int result = 0;
for (int i = 1; i <= A.size(); i++) {
for (int j = B.size(); j > 0; j--) {
if (A[i - 1] == B[j - 1]) {
dp[j] = dp[j - 1] + 1;
} else dp[j] = 0; // 注意这里不相等的时候要有赋0的操作
if (dp[j] > result) result = dp[j];
}
}
return result;
}
};
如果定义 dp[i][j]为 以下标i为结尾的A,和以下标j 为结尾的B,那么 第一行和第一列毕竟要进行初始化,如果nums1[i] 与 nums2[0] 相同的话,对应的 dp[i][0]就要初始为1, 因为此时最长重复子数组为1。 nums2[j] 与 nums1[0]相同的话,同理。 会更麻烦些。
// 版本三
class Solution {
public:
int findLength(vector<int>& nums1, vector<int>& nums2) {
vector<vector<int>> dp (nums1.size() + 1, vector<int>(nums2.size() + 1, 0));
int result = 0;
// 要对第一行,第一列经行初始化
for (int i = 0; i < nums1.size(); i++) if (nums1[i] == nums2[0]) dp[i][0] = 1;
for (int j = 0; j < nums2.size(); j++) if (nums1[0] == nums2[j]) dp[0][j] = 1;
for (int i = 0; i < nums1.size(); i++) {
for (int j = 0; j < nums2.size(); j++) {
if (nums1[i] == nums2[j] && i > 0 && j > 0) { // 防止 i-1 出现负数
dp[i][j] = dp[i - 1][j - 1] + 1;
}
if (dp[i][j] > result) result = dp[i][j];
}
}
return result;
}
};