C++ 子序列

已于 2024-03-21 21:54:18 修改
阅读量1.4k 收藏 9
点赞数 50
文章标签： c++ 算法 leetcode 动态规划
于 2024-03-21 13:34:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74922218/article/details/136903271
版权

目录

最长递增子序列 

 摆动序列

 最长递增子序列的个数

 最长数对链

 最长定差子序列

 最长的斐波那契子序列的长度

 最长等差数列

等差数列划分 II - 子序列 

最长递增子序列 

300. 最长递增子序列

 子数组是连续的，子序列可以不连续，那么就要去[0, i - 1] 区间找

参考代码

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        vector<int> dp(n, 1);
        int ret = 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;
    }
};

 摆动序列

 376. 摆动序列

错误： g[i] = max(g[i], f[j] + 1);这个地方写错成f[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[j] < nums[i]) f[i] = max(f[i], g[j] + 1);
                else if(nums[j] > nums[i]) g[i] = max(g[i], f[j] + 1);
            }
            ret = max(ret, max(f[i], g[i]));
        }
        return ret;
    }
};

 最长递增子序列的个数

673. 最长递增子序列的个数 ☆☆☆☆☆

逻辑其实差不多，我们需要用len来更新count，如果只表示一个count的话没有len，没法更新count；只有在nums[j] < nums[i] 的时候才能操作，这是递增的基本条件；然后通过长度来更新；大于自然要重置，等于则延续count[j]；通过for j 循环找出 i 位置为结尾的最长长度和最大个数

参考代码

class Solution {
public:
    int findNumberOfLIS(vector<int>& nums) {
        int n = nums.size();
        vector<int> len(n, 1), count(n, 1);
        int maxlen = 1, retcount = 1;
        for(int i = 1; i < n; i++)
        {
            for(int j = 0; j < i; j++)
            {
                
                if(nums[j] < nums[i])
                {
                    if(len[j] + 1 == len[i]) count[i] += count[j];
                    else if(len[j] + 1 > len[i])
                        len[i] = len[j] + 1, count[i] = count[j];
                }
            }
            if(len[i] > maxlen)
                maxlen = len[i], retcount = count[i];
            else if(len[i] == maxlen)
                retcount += count[i];
        }
        return retcount;
    }
};

 最长数对链

646. 最长数对链

 去[0,  i - 1] 里面找符合条件的，再比较

参考代码

class Solution {
public:
    int findLongestChain(vector<vector<int>>& pairs) {
        int n = pairs.size();
        sort(pairs.begin(), pairs.end());
        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[i], dp[j] + 1);
            }
            ret = max(ret, dp[i]);
        }
        return ret;
    }
};

 最长定差子序列

1218. 最长定差子序列

 最开始，老样子n方，但是发现超时；

class Solution5_1 {
public:
    int longestSubsequence(vector<int>& arr, int difference) {
        int n = arr.size();
        vector<int> dp(n, 1);
        int ret = 1;
        for (int i = 1; i < n; i++)
        {
            for (int j = 0; j < i; j++)
            {
                if (arr[j] + difference == arr[i]) dp[i] = max(dp[i], dp[j] + 1);
            }
            ret = max(ret, dp[i]);
        }
        return ret;
    }
};

然后发现只要找最后一个倒找，找到最后一个满足差值的就行；后面才发现，如果一个数据很长而且都满足条件的很少，那么这个时候优化就没有用了，

class Solution5_2 {
public:
    int longestSubsequence(vector<int>& arr, int difference) {
        int n = arr.size();
        vector<int> dp(n, 1);
        int ret = 1;
        for (int i = 1; i < n; i++)
        {
            for (int j = i - 1; j >= 0; j--)
            {
                if (arr[j] + difference == arr[i])
                {
                    dp[i] = dp[j] + 1;
                    break;
                }
            }
            ret = max(ret, dp[i]);
        }
        return ret;
    }
};

 所以我们采用hash<元素, 满足条件的个数>来映射

参考代码

class Solution {
public:
    int longestSubsequence(vector<int>& arr, int difference) {
        unordered_map<int, int> hash;
        int n = arr.size(), ret = 1;
        hash[arr[0]] = 1;
        for(int i = 1; i < n; i++)
        {
            hash[arr[i]] = hash[arr[i] - difference] + 1;
            ret = max(ret, hash[arr[i]]);
        }
        return ret;
    }
};

 最长的斐波那契子序列的长度

873. 最长的斐波那契子序列的长度

 如果是一维的状态表示：以i位置为结尾的最长斐波那契序列的长度，那么它的更新条件就要前面两个数，又要遍历两遍，但也不对，没法通过前面的状态来改变当前位置的状态；

所以用结尾两个位置来锁定这个斐波那契序列；自然就是二维dp

且是严格递增，hash可以直接全写出来(也可以一步一步定义)，且是<int , int> 每个元素只有一个对应的下标

注意：最后一步 oj题没有这时候只会报错，

参考代码

class Solution {
public:
    int lenLongestFibSubseq(vector<int>& arr) {
        int n = arr.size();
        vector<vector<int>> dp(n, vector<int>(n, 2));
        unordered_map<int, int> hash;
        for(int i = 0; i < n; i++)
            hash[arr[i]] = i;
        int ret = 2;
        for(int j = 2; j < n; j++)
        {
            for(int i = 1; i < j; i++)
            {
                int num = arr[j] - arr[i];
                if(hash.count(num) && hash[num] < i)
                    dp[i][j] = dp[hash[num]][i] + 1;
                ret = max(ret, dp[i][j]);
            }
        }
        return ret < 3 ? 0 : ret;
    }
};

一步步定义参考代码 

class Solution {
public:
    int lenLongestFibSubseq(vector<int>& arr) {
        int n = arr.size();
        vector<vector<int>> dp(n, vector<int>(n, 2));
        unordered_map<int, int> hash;
        // for(int i = 0; i < n; i++)
        //     hash[arr[i]] = i;
        hash[arr[0]] = 0;
        int ret = 2;
        for (int i = 1; i < n - 1; i++)
        {
            for (int j = i + 1; j < n; j++)
            {
                int num = arr[j] - arr[i];
                if (hash.count(num) && hash[num] < i)
                    dp[i][j] = dp[hash[num]][i] + 1;
                ret = max(ret, dp[i][j]);
            }
            hash[arr[i]] = i;
        }
        return ret < 3 ? 0 : ret;
    }
};

 最长等差数列

1027. 最长等差数列

 

以为我们需要元素对应的下标，所以用哈希表，

第二，这题并不是严格递增，那就是很可能会有相同的数，如果一次定义完哈希值，那么相同元素的下标就会用后面的那个，但是也可以定义为<int, vector<int>>

其三：每一次的 i  j 结尾都是不同的，所以ret必须要放在第二层循环里

注意 ret = 2, 题目是length >= 2 ，且两个数也被认为是构成等差数列

代码如下

class Solution {
public:
    int longestArithSeqLength(vector<int>& nums) {
        int n = nums.size();
        vector<vector<int>> dp(n, vector<int>(n, 2));
        int ret = 2;
        unordered_map<int, vector<int>> hash;
        for(int i = 0; i < n; i++)
            hash[nums[i]].push_back(i);
        for(int j = 2; j < n; j++)
        {
            for(int i = 1; i < j; i++)
            {
                int num = 2 * nums[i] - nums[j];
                // if(hash.count(num) && hash[num] < i)//不能这么写了因为hash[num]是vector<int>
                if(hash.count(num))
                    for(auto e : hash[num])
                        if(e < i)
                            dp[i][j] = max(dp[i][j], dp[e][i] + 1);
                ret = max(ret, dp[i][j]);
            }
        }
        return ret;
    }
};

 和 -> 最长定差子序列 想法类似，num只要找最接近 i 的就行,可以理解为覆盖掉原来的距离 i 较远元素的下标

参考代码

class Solution {
public:
    int longestArithSeqLength(vector<int>& nums) {
        int n = nums.size();
        vector<vector<int>> dp(n, vector<int>(n, 2));
        int ret = 2;
        unordered_map<int, int> hash;
        hash[nums[0]] = 0;
        for(int i = 1; i < n - 1; i++)
        {
            for(int j = i + 1; j < n; j++)
            {
                int num = 2 * nums[i] - nums[j];
                if(hash.count(num) && hash[num] < i)
                    dp[i][j] = dp[hash[num]][i] + 1;
                ret = max(ret, dp[i][j]);
            }
            hash[nums[i]] = i;
        }
        return ret;
    }
};

等差数列划分 II - 子序列 

 446. 等差数列划分 II - 子序列

 思路： 题目求的是个数，那么dp表要初始化成0，既然是子序列  个数 那么就是满足条件的所有下标（e），这里不能覆盖下标，要找到所有下标，所以hash是int 和vector<int> 对应,

两个i  j   for的顺序只对覆盖hash有影响作用

参考代码

class Solution {
public:
    int numberOfArithmeticSlices(vector<int>& nums) {
        int n = nums.size();
        vector<vector<int>> dp(n, vector<int>(n));
        unordered_map<long long, vector<int>> hash;
        for(int i = 0; i < n; i++)
            hash[nums[i]].push_back(i);
        int ret = 0;
        for(int i = 1; i < n - 1; i++)
        {
            for(int j = i + 1; j < n; j++)
            {
                long long num = (long long)2 * nums[i] - nums[j];
                if(hash.count(num))
                    for(auto e : hash[num])
                        if(e < i)
                            dp[i][j] += dp[e][i] + 1;
                ret += dp[i][j];
            }
        }
        return ret;
    }
};

EffectiveC++
关注
  • 50
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
求最长递增子序列个数——C++
净无邪博客
01-13 2538
​由于上一篇博客已经分析过求最长上升子序列长度——C++的经典LIS问题，该题是求最长增长子序列个数，经过分析，这题也只是经典LIS(Longest Increasing Subsequence)问题的变种，也就是用同样的LIS框架，区别在于本体需要额外记录每个最长子序列个数。下面是具体实现思路。 用dp[i]记录最长子序列长度maxLen，count[i]记录最长子序列个数，其中i表示数组的元素个数，0 <= i < n；如果求出前dp[i]和count[i]的i-1元素的值，则可以推导出：1.2代码实现
C++最长上升子序列
SkeletonKing233的博客
08-14 3868
现有数列a1，a2，a3……aN。在其中找到严格递增序列ai1，ai2，ai3，……aiK（1 <= i1 < i2 < i3 < …… < iK <= N），请找出序列a的最长上升子序列的长度，既K的最大值。
最长公共子序列C++实现
haust_允谦的博客
05-12 5074
最长公共子串,C++实现，附带思路解析
判断子序列c++（acwing）
falldeep的算法世界
06-23 817
题目 给定一个长度为n的整数序列a1,a2,…,an 以及一个长度为m的整数序列b1,b2,…,bm。 请你判断a序列是否为b序列的子序列。 子序列指序列的一部分项按原有次序排列而得的序列，例如序列{a1,a3,a5} 是序列{a1,a2,a3,a4,a5}的一个子序列。 输入格式 第一行包含两个整数n,m。 第二行包含nn个整数，表示a1,a2,…,an。 第三行包含mm个整数，表示b1,b2,…,bm。 输出格式 如果a序列是b序列的子序列...
判断子序列（C++解法）
m0_62275194的博客
09-25 313
给定字符串和，判断是否为的子序列。字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。truefalse。
算法题目：判断子序列 （C++）
weixin_52465547的博客
04-22 1703
判断子序列 今天偶然遇到这么一道题目，使用双指针的思路即可解题（简单），但是我看到了另一种的解法，当时的我想不出竟然还有这么一种解法，下面就用这一种解法来解答判断子序列这道算法题。 题目：判断子序列 给定字符串 s 和 t ，判断 s 是否为 t 的子序列。 字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。 示例 1： 输入：s = "abc", t = "ahbgdc" 输出：true
【C++】动态规划-求解子序列等系列问题
郝同学的博客
03-22 1824
一、问题背景   动态规划是一个对我而言比较复杂的一个问题，于是我想在这记录下我平时遇到过的动态规划的题目，以及总结其解体的通用思路。 二、问题求解 看到了有博主总结的dp的解题思路，我在这里分享给大家： 确定dp数组（dp table）以及下标的含义 确定递推公式 dp数组如何初始化 确定遍历的顺序 举例尝试推导dp数组 以下是leetcode中的相关的例子 1143. 最长公共子序列 给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，
C++输出一个整数序列所有子序列且子序列不重复（回溯法）
qq_41884662的博客
03-31 2245
用树的思想来看这道题，以nums={1,2,2}为例，先取1子序列，沿着1，递归继续往后取，path不断叠加子序列，同时result也不断实时更新将path加入，到底部以后先pop_back()弹出，递归返回上一层，如果发现下一个循环中要取的元素和前一个取的相同，则路径重复，不能再取了，pop_back，继续返回上一层，以此类推，每个大路径的子路径都是一部回溯，直至回溯至根部，继续下一个大路径的递归然后回溯，即可得出结果。 回溯法思路是：搜索每一条路，每次回溯是对具体的一条路径而言的。对当前搜索路径下的..
C/C++解子序列的和
My_YueR的博客
04-20 1360
输入两个正整数n<m<10^6，输出++ · · · +，保留5位小数。输入包含多组数据。结束标记位 n = m = 0。 样例输入： 2 5 65536 655360 0 0 样例输出： Case 1: 0.42361 Case 2: 0.00001
最长上升子序列C++
m0_50695845的博客
12-20 960
#include<iostream> #include<cstring> #include<string> using namespace std; const int MAXN = 10050; int main() { int n; cin>>n; while(n--){ string s; cin>>s; int len=s.length(),tMAX=-0x3f3f3f3f,dp[MAXN]; dp[0]=1; .
最大公共子序列的c++实现
09-01
问题描述 给定两个字符串，求解这两个字符串的最长公共子序列（Longest Common Sequence）。比如字符串1：BDCABA；字符串2：ABCBDAB ...则这两个字符串的最长公共子序列长度为4，最长公共子序列是：BCBA
c++语言写最长公共子序列问题
07-07
用c++语言写的最长公共子序列问题，比较经典的动态规划问题。能完美运行，输入2个字符串序列之后就能得出最长公共子序列。
利用C++实现最长公共子序列与最长公共子串
12-31
子串应该比较好理解，至于什么是子序列，这里给出一个例子：有两个母串 cnblogs belong 比如序列bo, bg, lg在母串cnblogs与belong中都出现过并且出现顺序与母串保持一致，我们将其称为公共子序列。最长公共子序列...
最长公共子序列算法设计与实现(c++).zip
11-22
算法工程项目问题描述： 【题目】 动态规划思维训练——最长公共子序列算法的设计与实现 给定两个序列X={X1, X2,···,Xm}和...字符串Y:{ABCBDAB}，则这两个字符串的最长公共子序列长度为4，最长公共子序列是：BCBA
最短子序列
10-20
使用C++实现最短子序列，对正在学习算法的同学应该挺有帮助的
C++中的智能指针类别
最新发布
GOLOJO的博客
05-31 661
C++中的智能指针是用来管理动态内存的对象，避免我们手动管理内存时可能会带来的复杂性和错误。C++标准库提供了几种不同类型的智能指针，包括``、``和`- 优先使用``和``来创建智能指针，避免手动使用`new`，可以提高代码的安全性和性能。- 在使用``时要特别小心循环引用的问题。可以使用``来打破循环引用。- 确保智能指针的生命周期管理正确，避免悬空指针和内存泄漏。- 虽然智能指针极大地简化了内存管理，但也带来了额外的开销，如引用计数的维护。因此，在性能敏感的代码中，应慎重使用`
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 797
string类各函数接口。
C语言——指针
weixin_45725380的博客
05-31 490
存储类型 数据类型 *指针变量名；例如：int *p;//定义了一个整数型指针变量pint a=5;int *p=&a;char b='v';char *q=&b;访问指针所指的空间里的内容时，需要用取内容运算符*来获取此时，变量p存放的就是a的地址，变量q存放的就是b的地址；符号*可以访问地址指向的空间里面的内容。指针与变量之间的关系如下：int i=3;本质还是指针，指向的是数组。（又称为行指针）所谓指针数组就是由若干个具有相同类型的指针变量组成的集合。
C++候捷stl-视频笔记2
Mhypnos的博客
05-31 554
候捷stl标准库学习笔记
c++数组实现子序列
05-28
在 C++ 中，可以通过定义数组来实现子序列。 假设我们要实现的子序列是原序列中下标从 l 到 r 的一段区间，那么可以定义一个长度为 n 的数组 arr，其中 arr[i] 表示原序列中下标为 i 的元素。然后，子序列可以表示...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值