LeetCode 491. 递增子序列

最新推荐文章于 2024-07-28 20:22:01 发布
原创 最新推荐文章于 2024-07-28 20:22:01 发布 · 178 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文探讨了在给定整型数组中寻找所有递增子序列的问题，子序列长度至少为2。通过示例详细解释了算法实现过程，包括如何处理重复数字并确保递增条件。介绍了基于深度优先搜索(DFS)的解决方案，并使用手动去重技巧来优化结果。

给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。

示例:

输入: [4, 6, 7, 7]
输出: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]]


说明:

给定数组的长度不会超过15。
数组中的整数范围是 [-100,100]。
给定数组中可能包含重复数字，相等的数字应该被视为递增的一种情况。

?     https://leetcode-cn.com/problems/increasing-subsequences

求子集问题 思路和 leetcode 90 思路类似   应该不是最好的,因为最后产生的结果还要加一步手动去重。。 去重先排序 + O(n) 的方式去重
class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    
    void dfs(vector<int>& nums,int u){
        if (u == nums.size()){
            if (path.size() >= 2)
                res.push_back(path);
            return;
        }
        
        int k = 0;
        while(u + k < nums.size() && nums[u + k] == nums[u]) ++k;
        
        if (path.size() && nums[u] >= path.back()){
                for (int i = 0; i <= k; ++i){
                    dfs(nums,u + k);
                    path.push_back(nums[u]);
                }
                for (int i = 0; i <= k; ++i)
                    path.pop_back();
            }
        else if (!path.size()){
            for (int i = 0; i <= k; ++i){
                dfs(nums,u+k);
                path.push_back(nums[u]);
            }
            for (int i = 0; i <= k; ++i)
                path.pop_back();
        }
        else    
            dfs(nums,u + k);
    }
    
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        dfs(nums,0);
        int h = 0;
        int t = 0;
        sort(res.begin(),res.end());
        for (int t = 0; t < res.size(); ++t){
            if (res[t] != res[h])
                swap(res[++h],res[t]);
        }
        while(res.size() > h + 1)
            res.pop_back();
        return res;
    }
};

 

leetCode 300.最长递增子序列 (贪心 + 二分 ) + 图解 + 优化 + 拓展
呵呵哒!的博客
10-07 1806
子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序”dp[i]表示 i 之前包括 i 的以 nums[i] 结尾的最长递增子序列的长度。这里就用反证法来证明，如果 g 不是严格递增的，比如说 g = [1,6,6] 那么最后的这个 6 肯定会对应一个长为 3 的，末尾为 6 的上升子序列，那第二个数是小于等于5的，而这就和第一个6矛盾了，它表示第二个数最小是6。所以通过反证法，我们可以得出 g 一定是一个严格递增的序列，知道 g 是严格递增的，就可以得出后面的结论了。
leetcode 491. 递增子序列 思考分析
hanhan的博客
11-10 367
题目 给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。 说明: 给定数组的长度不会超过15。 数组中的整数范围是 [-100,100]。 给定数组中可能包含重复数字，相等的数字应该被视为递增的一种情况。 思考 这一题和leetcode 90. 子集 II 思考分析的思想有点像。 但是需要注意的是： 1、该数组是求递增子序列，所以不能打乱原数组的顺序。 2、递增子序列 3、递增子序列的长度最少是2 其它的思想：回溯、去重其实和leetcode 90. 子集 II 思考分析
LeetCode491
xxu_tianxin的博客
02-05 276
递增子序列 考察知识点：DFS+Set(去重) 样例： [4, 6, 7, 7] ans: [4,6] [4,7] [4,6,7] [4,7,7] [4,6,7,7] [6,7] [6,7,7] [7,7] public static List<List<Integer>> findSubsequences(int[] nums){ Set<List&...
leetcode(力扣) 491. 递增子序列（回溯 & 去重思路）
深度不学习！！的博客
10-28 530
这是这道题比较有意思的地方，终止条件可以理解为，收集结果的地方，实际上对于包括之前的子集问题，是没有终止条件的，就是任何子节点的结果都需要，而这道题唯一需要注意的两个地方就是，当前记录的答案里面是不是的元素是不是大于1个，而且是不是递增的。输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]因为这道题需要去重，而又不能用之前组合总和2里的那个去重思路，因为这是找子序列，不能排序，排序之后顺序就乱了。输出：[[4,4]]
leetcode：491. 递增子序列
OceanStar的博客
05-15 563
题目来源 leetcode：increasing-subsequences 题目描述 题目解析 回溯 即枚举出所有的子序列，然后判断当前的子序列是否是严格递增的，然后还需要去重。所以我们需要解决两个问题： 如何枚举出所有的子序列 如何判断子序列是严格递增的 如何对子序列去重 怎么枚举出所有的子序列呢？ 可以遍历nums中数组的每一个值，每个元素都有两种选择，要么加入tmp数组，要么不加。 void dfs(std::vector<int> &nums, std::vect
leetcode491（递增子序列：回溯法）
CY2333333的博客
08-25 370
给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。 示例: 输入: [4, 6, 7, 7] 输出: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]] 题解：利用回溯法找到数组所有的子序列，然后判断该子序列是否是递增序列，同时也要维护一个哈希表用于去重 class Solution { /* * res用于存储最终结果 * stack用于实现回溯算
(LeetCode) 491. Increasing Subsequences
shawnNg的博客
05-30 297
491. Increasing SubsequencesGiven an integer array, your task is to find all the different possible increasing subsequences of the given array, and the length of an increasing subsequence should be at
算法Day22 | Leetcode491.递增子序列、46.全排列、47.全排列 II、332.重新安排行程、51. N皇后
m0_73799676的博客
07-28 520
回溯，做冲突判断的时候，传入当前行当前列，然后第一判断是否发生列冲突，第二往左上角判断是否发现对角线冲突，第三往右上角判断是否发现对角线冲突。如果不冲突，就将棋盘该位置换成Q,然后将该层转成字符串加入路径集，回溯的时候记得从路径集删除，并且将Q从棋盘中换回.回溯，根据目的地做字母排序。跟全排列同理，从0往后找，找出发地与上一个目的地相同的并且没有使用过的，加入路径集。但是可能出现：1层：4；回溯，与子集不同的是，全部元素都要加进去，不能每次进入函数就将路径集加入结果集。举个例子：1层：4；
LeetCode 300. 最长递增子序列
lly-Rachel的博客
09-02 264
一、问题描述 给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。 子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。 二、测试数据 示例 1： 输入：nums = [10,9,2,5,3,7,101,18] 输出：4 解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。 示例 2： 输入：nums = [0,1,0,3,2,3] 输出：4 示例 3： 输入：nums =
LeetCode 674. 最长连续递增序列【Python】
"大梦三千秋的博客
01-24 659
思路：双指针
【LeetCode】491. Increasing Subsequences 解题报告（Python）
负雪明烛
04-05 2229
【LeetCode】491. Increasing Subsequences 解题报告（Python） 标签（空格分隔）： LeetCode 题目地址：https://leetcode.com/problems/increasing-subsequences/description/ 题目描述： Given an integer array, your task is to fin...
【Leetcode】491. Increasing Subsequences
u010900754的专栏
03-11 524
题目：https://leetcode.com/problems/increasing-subsequences/?tab=Description 找出所有的长度大于等于2的递增序列。 思路：这里是找出所有的解。因此选择backtracking。要注意一点，关于去重。之前做过类似的，combinationsum那种，那个类型的题目是从集合中选元素，因此集合的顺序无关紧要，但是这里是序列，顺序是
【leetcode】491. Increasing Subsequences
weixin_34080903的博客
05-09 145
题目如下： 解题思路：这题把我折腾了很久，一直没找到很合适的方法，主要是因为有重复的数字导致结果会有重复。最后尝试用字典记录满足条件的序列，保证不重复，居然Accept了。 代码如下： class Solution(object): def findSubsequences(self, nums): """ :type nums: Lis...
【LeetCode】 491. Increasing Subsequences
LSF_Kevin的博客
01-23 1917
Given an integer array, your task is to find all the different possible increasing subsequences of the given array, and the length of an increasing subsequence should be at least 2 . Example: In
<LeetCode>491. 递增子序列
Sonihr的犀牛园
04-28 738
给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。示例:输入: [4, 6, 7, 7] 输出: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]]说明:给定数组的长度不会超过15。数组中的整数范围是 [-100,100]。解题思路——1. 我之前一直对递归中套循...
leetcode 491
CJMINGMING的博客
11-29 409
思路一： 1.首先我们确定一个结果集合res和一个临时路径集合temp。 2.遍历数组的每个元素，对于每个元素，有取和不取两种选择，使得对应的temp不同，当我们遍历完最后一个元素时，需要将temp加入res当中。 3.由于题目要求是递增序列，所以在取之前我们需要判断当前元素是否大于等于temp当中最后一个元素，如果不满足，则不取当前元素，然后继续递归遍历下一个元素。 4.如果满足的话，我们将当前元素加入temp当中，然后递归遍历下一个元素。在递归回溯之后，我们还需要考虑当前元素不取的情况，所以我们需要将当
[Swift]LeetCode491. 递增子序列 | Increasing Subsequences
weixin_30322405的博客
02-02 149
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★➤微信公众号：山青咏芝（shanqingyongzhi）➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）➤GitHub地址：https://github.com/strengthen/LeetCode➤原文地址：https://www.cnblogs.com/streng...
[回溯]leetcode491：递增子序列(medium)
algsup
01-29 471
题目： 题解： 回溯法一般套路，生成组合问题，这里注重讲一下index吧。 由于是生成组合并不是生成排序，所以进行下一次决策的话，我们需要将i+1，表示i表示的数字已经加入决策路径了，只有回溯回来的时候i+1会还原成i，然后++i，我们重新生成下一个组合。 代码如下： class Solution { public: vector<vector<int>>...
LeetCode 491. 递增子序列（C++）
qq_27060423的博客
12-16 1056
给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。 示例: 输入: [4, 6, 7, 7] 输出: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]] 说明: 给定数组的长度不会超过15。 数组中的整数范围是[-100,100]。 给定数组中可能...
leetcode 674.最长连续递增序列
最新发布
03-19
### 解题思路 LeetCode 第 674 题的目标是找到给定数组中的最长连续递增子序列的长度。此问题可以通过一次线性扫描来解决，时间复杂度为 O(n)，空间复杂度可以优化到 O(1)[^1]。 #### 关键点分析 - **连续性**：题目强调的是“连续”，因此只需要比较相邻两个元素即可判断是否构成递增关系。 - **动态规划 vs 贪心算法**：虽然可以用动态规划的思想解决问题，但由于只需记录当前的最大值而无需回溯历史状态，贪心策略更为高效[^3]。 --- ### Python 实现 以下是基于贪心算法的 Python 实现： ```python class Solution: def findLengthOfLCIS(self, nums): if not nums: # 如果输入为空，则返回0 return 0 max_len = 1 # 至少有一个元素时，最小长度为1 current_len = 1 # 当前连续递增序列的长度初始化为1 for i in range(1, len(nums)): # 从第二个元素开始遍历 if nums[i] > nums[i - 1]: # 判断当前元素是否大于前一个元素 current_len += 1 # 是则增加当前长度 max_len = max(max_len, current_len) # 更新全局最大长度 else: current_len = 1 # 否则重置当前长度 return max_len # 返回最终结果 ``` 上述代码通过维护 `current_len` 和 `max_len` 来跟踪当前连续递增序列的长度以及整体的最大长度。 --- ### Java 实现 下面是等效的 Java 版本实现： ```java public class Solution { public int findLengthOfLCIS(int[] nums) { if (nums.length == 0) { // 处理边界情况 return 0; } int maxLength = 1; // 初始化最大长度 int currentLength = 1; // 初始化当前长度 for (int i = 1; i < nums.length; i++) { if (nums[i] > nums[i - 1]) { // 若满足递增条件 currentLength++; // 增加当前长度 maxLength = Math.max(maxLength, currentLength); // 更新最大长度 } else { currentLength = 1; // 不满足递增条件时重新计数 } } return maxLength; // 返回结果 } } ``` 该版本逻辑与 Python 类似，但在语法上更贴近 Java 的特性[^4]。 --- ### C++ 实现 对于 C++ 用户，下面是一个高效的解决方案： ```cpp #include <vector> #include <algorithm> // 使用 std::max 函数 using namespace std; class Solution { public: int findLengthOfLCIS(vector<int>& nums) { if (nums.empty()) { // 边界处理 return 0; } int result = 1; // 结果变量 int count = 1; // 当前连续递增序列长度 for (size_t i = 1; i < nums.size(); ++i) { if (nums[i] > nums[i - 1]) { // 检查递增条件 count++; result = max(result, count); } else { count = 1; // 重置计数器 } } return result; // 返回最终结果 } }; ``` 这段代码同样遵循了单次遍历的原则，并利用标准库函数简化了一些操作。 --- ### 小结 三种语言的核心思想一致，均采用了一种简单的线性扫描方式完成任务。这种方法不仅易于理解，而且性能优越，在实际应用中非常实用[^2]。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值