LeetCode刷题: 【300】 最长上升子序列(动态规划 / 贪心算法)

最长上升子序列(动态规划) 子序列 所谓的子序列就是在原来序列中找出一部分组成的序列。 与子段不同,不需要连续的某一段,但是要保持原序列的先后顺序 最长上升子序列 在子序列的基础上,后一项大于前一项。 【题目描述... 阅读详情

1. 题目

在这里插入图片描述

2. 解法(动态规划)

2.1 解题思路

比暴力法(使用回溯法遍历所有子序列,判定严格上升序列,并取最大值,时间复杂度O(n*2^n))好,动态规划,分别计算以每个元素结束的上升子序列长度,需要向前遍历寻找最长上升子序列,再加1,时间复杂度O(n^2)

2.2 代码

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        // 解空间 
        // 保存以nums[i]结尾的最长上升子序列长度
        // 初始时单个数字为最长上升子序列 默认值为1
        vector<int> dp(nums.size(), 1);
        int ans = 0; // 答案

        for(int i = 0; i < nums.size(); i++){
            int max = 0; // 当 j < max 时,子序列长度已经不可能比max大了
            for(int j = i; j >= max; j--){
                if(nums[i] > nums[j] && dp[j] > max){
                    max = dp[j];
                }
            }
            // 状态转移公式
            // dp[i] = max{ dp[j] | 0 <= j < i, nums[i] > nums[j] } + 1
            dp[i] = max + 1;
            if(dp[i] > ans){
                ans = dp[i];
            } // 记录最长上升子序列长度
        }

        return ans;
    }
};

3. 解法(贪心算法)

3.1 解题思路

贪心思想:当目前保存的上升序列末尾越小,越可能延长
在遍历nums的过程中,保存长度为i的上升序列的最小末尾为tail[i]


  1. 当nums[i]大于所有tail (即 > tail[max_length]) 时,说明当前维护的最长上升序列末尾应追加元素,使tail追加元素nums[i],max_length+1
  2. 当tail中存在等于nums[i]的元素,说明以nums[i]结尾的上升序列已存在
  3. 替换第一个比nums[i]大的tail,说明tail该位置对应长度的上升序列可以有一个更小的末尾【注:此操作不会影响更长的上升序列,而是继承更短的上升序列变化,故贪心有效 (请看 流程解析 )】

tail在计算过程中始终保持严格单调递增
所以可以使用二分法定位第一个比nums[i]大的tail的位置
最终tail的长度即为最长上升子序列长度
时间复杂度 O(n * logn)

3.2 流程解析

示例:[10, 9, 2, 5, 3, 7, 101, 18, 6, 22, 11, 9]
以下为上升序列搜索和维持示意,
其中各序列末尾为tail元素,行数自上而下为序列长
最后一行为当前最长上升序列(与tail不一定一样)


10 :长度为1的上升序列


9 :替换缩小


2 :替换缩小


2
2 5 :延伸长度1的序列为长度2


2
2 3 :替换缩小长度为2的序列末尾元素


2
2 3
2 3 7 :延伸长度2的序列为长度3


2
2 3
2 3 7
2 3 7 101 :延伸长度3的序列为长度4


2
2 3
2 3 7
2 3 7 18 :替换缩小长度为4的序列末尾元素


2
2 3
2 3 6 :替换缩小长度为3的序列末尾元素
2 3 7 18 》 此时6在18右侧,所以7不变


2
2 3
2 3 6
2 3 7 18 》 此时由于6在18右侧,只能延长第4行,不受之前行影响
2 3 7 18 22 :延伸长度4的序列为长度5


2
2 3
2 3 6
2 3 6 11 :替换缩小长度为4的序列末尾元素,可继承更短序列
2 3 7 18 22 》此时由于11在22右侧,不能继续继承


2
2 3
2 3 6
2 3 6 9 :替换缩小长度为4的序列末尾元素
2 3 7 18 22 》此时由于9在18右侧,不能继承


最终最长上升子序列【2 3 7 18 22】长度为 5

3.2 代码

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        // 辅助空间 在计算过程中保持严格单增
        // tail[i] = 长度为i的上升子序列的最小末尾 
        vector<int> tail(nums.size() + 1, INT_MIN);
        int max_length = 0; // 已知最长上升子序列长度

        for(int i = 0; i < nums.size(); i++){
            if(nums[i] > tail[max_length]){
                // 如果num[i]严格大于所有tail,则追加
                // 在计算过程中保持严格单增
                // 即最长上升子序列+1,并以num[i]结尾
                tail[++max_length] = nums[i];
            }else{
                // 使用二分搜索定位第一个大于num[i]的tail
                int l = 0, r = max_length;
                while(l <= r){
                    int mid = (l + r) >> 1; // 位运算 除以2
                    if(tail[mid] < nums[i]){
                        l = mid + 1;
                    }else{
                        // 当tail中含有相等num[i]的元素时不必进行替换操作,此处为了写法简便,进行了替换
                        r = mid - 1;
                    }
                }
                // 替换(缩小)第一个大于num[i]的上升子序列的最小末尾
                tail[l] = nums[i];
            }/*
            for(int q = 1; q <= max_length; q++){
                cout<<tail[q]<<" ";
            }
            cout<<endl;*/
        }

        // 最终tail的长度即为最长上升子序列长度
        return max_length;
    }
};

3.3 疑问

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        // 辅助空间 在计算过程中保持严格单增
        // tail[i] = 长度为i的上升子序列的最小末尾 
        vector<int> tail(nums.size() + 1, INT_MIN);
        int max_length = 0; // 已知最长上升子序列长度

        for(int i = 0; i < nums.size(); i++){
            if(nums[i] > tail[max_length]){
                // 如果num[i]严格大于所有tail,则追加
                // 在计算过程中保持严格单增
                // 即最长上升子序列+1,并以num[i]结尾
                tail[++max_length] = nums[i];
            }else{
                // 使用二分搜索定位第一个大于num[i]的tail
                int l = 0, r = max_length;
                int mid = 0;
                while(l < r){
                    mid = (l + r) / 2;
                    if(tail[mid] == nums[i]){
                        // 当tail中含有相等num[i]的元素时不能进行替换操作
                        mid = -1;
                        break;
                    }else if(tail[mid] < nums[i]){
                        l = mid + 1;
                    }else{
                        r = mid - 1;
                    }
                }
                if(mid != -1){
                    // 替换(缩小)第一个大于num[i]的上升子序列的最小末尾
                    // 此处即使不进行if-else判断也可以通过LeetCode
                    // 但是这样并没有保证每次换掉的是第一个更大的
                    // tail序列将会不同,但长度不变
                    // 可能的猜想:
                    // 1. 算法可以优化,可能不需要保存所有之前更短的状态
                    // 2. LeetCode判例不足
                    //if(tail[l] > nums[i])
                        tail[l] = nums[i];
                    //else
                    //    tail[l+1] = nums[i];
                }
            }
            // for(int q = 1; q <= max_length; q++){
            //     cout<<tail[q]<<" ";
            // }
            // cout<<endl;
        }

        // 最终tail的长度即为最长上升子序列长度
        return max_length;
    }
};

经测试,在这里插入图片描述
[11,12,13,14,15,16,1,2,3,4,1,5,6,7,1,8]
无法通过该判例,但LeetCode官网可以提交通过

最长上升子序列 (LIS) 详解+例题模板 (全) 欢迎访问https://blog.youkuaiyun.com/lxt_Lucia~~ 宇宙第一小仙女\(^o^)/~~萌量爆表求带飞=≡Σ((( つ^o^)つ~ dalao们点个关注呗~~ ------------------------------------我只是一条可爱哒分界线-------------------------------------- 1.摘要: 关... 阅读详情

相关推荐

【LeetCode】300. 最长上升子序列:给定一个无序的整数数组,找到其中最长上升子序列的长度

【LeetCode】300. 最长上升子序列 给定一个无序的整数数组,找到其中最长上升子序列的长度。 示例: 输入: [10,9,2,5,3,7,101,18] 输出: 4 解释: 最长的上升子序列是 [2,3,7,101],它的长度是 4。 说明: 可能会有多种最长上升子序列的组合,你只需要输出对应的长度即可。 你算法的时间复杂度应该为 O(n2) 。 进阶: 你能将算法的时间复杂度降低到 O(...

weixin_42956047的博客 3754

『动态规划』最长上升子序列

给出一串正整数,如下 能找到最长的单调递增的子序列为 2. 动态规划法 2.1 设计思路 设b[i]是在a[i]为单调递增子序列最后一个元素时,所得最长单调递增子序列 的长度为:思路:最长递增子序列空间复杂度:S(n) 2.4 算法优化 2.4.1 优化分析 内层循环所作的操作是在区间找到比小且状态值最大的数,就是一个查找的过程,我们所熟知的二分查找的效率是,可不可以用二分来优化这个内层循环呢?维护两个数组我们所要做的操作就是依次遍历序列中后续元素,更新两个数组分析这么多其实理解了就是两行话老师的ppt绕

一个专注于客户端开发的技术er,不定期更新Android,Flutter,HormonyOS等方向的使用心得和感悟 3547

高速数字信号硬件设计:灵巧手方向核心技能与实战解析

在机器人产业加速演进的今天,灵巧手等高自由度末端执行器对硬件电路设计提出了更高要求。传统硬件工程师熟悉功能、功耗与EMC,而灵巧手设计还需在极小空间内融合多路电机驱动、高速数字接口与微弱模拟信号采集。信号完整性与电源完整性成为决定系统稳定性的关键:信号上升沿决定有效带宽,阻抗匹配、回流路径和去耦策略直接影响通信质量与抗干扰能力。从阻抗计算、等长设计到FPC布线,再到电源预算与纹波抑制,这些高速数字信号设计基础原理不仅适用于服务器主板,更是灵巧手控制器开发与调试的必修课。本文面向从事机器人硬件、嵌入式系统与电

weixin_29172963的博客 239

动态规划__最长上升子序列

则最大长度为以每一个a[i]结尾的最大值f[i]的最大值遍历整个a数组,用q数组来存储所有不同长度的上升子序列的最小值用二分来求q数组中第一个小于等于a[i]的数,并且将len和q数组更新。

Zo_ee的博客 2577

数字加网(一)— —概念及分色合成

由于大多数图像复制设备是二值设备,因此在图像复制过程中,必须先把连续调的灰度图像或彩色图像处理成二值的半色调图像,用单位面积的网点覆盖率来表现图像的颜色深浅变化。这个过程被称之为加网(Screening) 数字加网就是根据人眼视觉的空间混色特性,用人眼无法分辨的细小黑白点的单位覆盖面积来模拟灰度图像或彩色图像的层次变化,使得到

Sin_Geek成长の迹 8597

大模型时代必备技能:3种向量量化技术对比(PQ/AQ/RVQ)与选型指南

本文深入解析了大模型时代处理海量向量数据的关键技术——向量量化。通过对比Product Quantization (PQ)、Additive Quantization (AQ)和Residual Vector Quantization (RVQ)三种主流技术的核心原理、性能表现与适用场景,为工程师提供了从理论到实践的选型指南,旨在解决向量存储与检索的效率瓶颈,助力RAG等大模型应用高效落地。

silver的专栏 801

LeetCode 第 300 题:最长上升子序列(动态规划、贪心算法)

地址:https://leetcode-cn.com/problems/longest-increasing-subsequence/ 我写的题解地址:https://leetcode-cn.com/problems/longest-increasing-subsequence/solution/dong-tai-gui-hua-er-fen-cha-zhao-tan-xin-suan-fa-p/...

李威威的博客 1282

【ArcGIS遇上Python】使用add-in向导开发ArcGIS插件(1):add-in工具介绍及安装

文章目录addin介绍addin下载addin安装 addin介绍 ArcGIS从10.0开始支持addin(ArcGIS软件中又叫作加载项)的方式进行插件制作。相对于以往9.x系列,addin的无论是从使用或者编写都更加方便快捷。通过开发语言,可以制作ArcGIS Desktop各个软件模块的插件。 Esri提供了Python加载项向导工具来实现Addin界面的搭建,可以到Esri官网去下载该工具Python加载项向导 。从介绍来看,该设计器要求的最低ArcGIS版本为10.1 ,如下图所示: add

智慧空间实验室 7207

LeetCode300. 最长递增子序列(动态规划 / 贪心)

LeetCode300. 最长递增子序列(动态规划 / 贪心)

向未来❀去探索 的博客 4156

OP-TEE虚拟化支持详解

OP-TEE虚拟化支持解析 OP-TEE提供实验性虚拟化方案,支持多虚拟机共享安全执行环境。核心特性包括: 配置选项:CFG_VIRTUALIZATION启用虚拟化,CFG_VIRT_GUEST_COUNT限制虚拟机数量并分配均等内存资源; Hypervisor协作:需实现虚拟机生命周期通知、SMC参数转换、内存固定等关键协议; 当前限制:仅支持Armv8架构,硬件资源共享有限,采用静态内存配额机制; 架构实现:通过MMU分区切换和扩展内存分配器实现多租户隔离,Nexus核心层管理虚拟机上下文。该方案适用于

Linux内核架构师 110

国产SerDes芯片(4)—纳芯微 NLS9116+NLS9246

本系列文章主要讲解国产SerDes芯片—纳芯微 NLS9116+NLS9246的相关知识。

零零刷的博客 824

Leetcode题300、最长上升子序列(Python题解)经典题

问题: 题目来源:力扣(LeetCode) leetcode300.最长上升子序列 难度:简单 分析: 经典题。 一、动态规划 观察数组,要求数组的最长上升子序列,可以想到长度为i的子序列可以由长度为i - 1的递推而来,因此考虑动态规划。那么动态规划的状态空间该如何定义呢? 思考最长上升子序列的寻找过程,当我们遍历到数组的i位置时,无法判断最终的最长子序列是由i结尾的所属的子序列还组成还是由i - 1结尾或者其他的子序列组成。因此我们需要把位置i之前的所有位置所在的子序列的长度都记录下来。 因此我们这样

AI414010的博客 659

汽车UDS诊断之诊断会话控制服务(0x10)深度剖析

DiagnosticSessionControl就是诊断会话控制。 请求消息定义 A_Data类型 参数名称 Cvt 字节值 助记符 #1 诊断会话控制请求SID M 0x10 DSC #2 子功能=[诊断会话类型] M 0x00-0xFF LEV_DS_ ...

心骗小白话的博客 7422

力扣300——最长上升子序列

这道题主要涉及动态规划,优化时可以考虑贪心算法和二分查找。 原题 给定一个无序的整数数组,找到其中最长上升子序列的长度。 示例: 输入: [10,9,2,5,3,7,101,18] 输出: 4 解释: 最长的上升子序列是[2,3,7,101],它的长度是 4。 说明: 可能会有多种最长上升子序列的组合,你只需要输出对应的长度即可。 你算法的时间复杂度应该为O(n2) 。 进阶: 你...

death05的博客 1262

【学习系列】SAP RAP 8:行为定义-Authorization Control

本文介绍了SAP RAP中的授权控制实现方法,主要分为读取操作和修改操作两种场景。读取操作通过ABAP CDS的数据控制语言(DCL)实现,使用访问控制对象限制数据可见范围;修改操作则通过行为定义中的权限检查,包括全局授权、实例授权和预检查三种方式。文章详细说明了如何使用DCL创建访问控制规则,并通过实例演示了全局授权和实例授权的代码实现方法,以及预检查功能在数据更新前的权限验证。这些授权控制机制共同确保用户只能访问和操作其权限范围内的数据,有效保障系统安全性。

DeveloperMrMeng的博客 440

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

力扣小白刷题之300题最长上升子序列

题目描述 给定一个无序的整数数组,找到其中最长上升子序列的长度。 说明: 可能会有多种最长上升子序列的组合,你只需要输出对应的长度即可。 你算法的时间复杂度应该为 O(n^2) 。 思路 动态规划 定义状态 dp[i] 表示 以 nums[i] 为结尾的上升子序列的长度。注意:nums[i] 必须选取且必须是这个子序列的最后一个元素。 考虑状态转移方程 遍历到 nums[i] 时,需要把下标 i 之前的所有的数都看一遍 只要 nums[i] 严格大于在它位置之前的某个数,那么 nums[i] 就可

weixin_43525710的博客 359

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

leetcode一题打尽动态规划和贪心算法之300. 最长上升子序列

动态规划和贪心算法的知识点 动态规划的核心思想是把原问题分解成子问题进行求解,也就是分治的思想。 贪心算法(又称贪婪算法)是指,在对问题求解时,总是做出在当前看来是最好的选择。也就是说,不从整体最优上加以考虑,他所做出的是在某种意义上的局部最优解。 题目 给定一个无序的整数数组,找到其中最长上升子序列的长度。 示例: 输入: [10,9,2,5,3,7,101,18] 输出: 4 解释: 最长的...

程序员早早的博客 370

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

LeetCode刷题指南 - 动态规划篇

LeetCode刷题指南 - 动态规划篇

weixin_622464的博客 1463

leetcode 300 Longest Increasing Subsequence 最长上升子序列 动态规划

leetcode 300 Longest Increasing Subsequence 最长上升子序列 leetcode 2020年3月 每日一题打卡 据说华为问过这道题 问题: 给定一个无序的整数数组,找到其中最长上升子序列的长度。 示例: 输入: [10,9,2,5,3,7,101,18] 输出: 4 解释: 最长的上升子序列是 [2,3,7,101],它的长度是 4。 说明: 可能会有多...

weixin_43973433的博客 211

InterviewGuide 刷题笔记:力扣 300. 最长上升子序列,从 O(n²) 动态规划到 O(n log n) 贪心 + 二分

本篇技术指南基于 InterviewGuide 仓库中阿秀的 LeetCode 刷题笔记整理,围绕力扣第 300 题「最长上升子序列(Longest Increasing Subsequence,LIS)」展开:先讲清题意与边界条件,再给出两套可以直接上手的 C++ 解法——经典的 O(n²) 动态规划,以及面试官最常追问的 O(n log n) 贪心 + 二分优化,并对状态定义、转移方程、二分查

gitblog_00762的博客 434

LeetCode第 300 题:最长上升子序列(C++)

300. 最长上升子序列 - 力扣(LeetCode) 这个状态感觉不好定义啊,如果把子序列的长度定义为状态,就很难定义 动态规划 动态规划 、优化(以贪心和二分作为子过程) - 最长上升子序列 - 力扣(LeetCode) 为了从一个较短的上升子序列得到一个较长的上升子序列,主要关心这个较短的上升子序列结尾的元素。由于要保证子序列的相对顺序,在程序读到一个新的数的时候,如果比已经得到的子序列的最后一个数还大,那么就可以放在这个子序列的最后,形成一个更长的子序列; 假设dp[i]表示以元素nums[i]为最

zj 541

LeedCode300 最长上升子序列问题 动态规划 和 二分查找+贪心算法的区别

最长上升子序列3.5最长上升子序列3.5.1题目描述3.5.2思路与算法3.5.4其他方法对比方法1和方法2的if语句判定条件,就能想明白了 3.5最长上升子序列 3.5.1题目描述 LeedCode题目:300.最长上升子序列 描述: 给定一个无序的整数数组,找到其中最长上升子序列的长度。 示例: 输入: [10,9,2,5,3,7,101,18] 输出: 4 解释: 最长的上升子序列是 [2,3,7,101],它的长度是4。 3.5.2思路与算法 首先要明确这个题目只需要求上升子序列的个数,不用具体求出

偶尔想看云飞的博客 266

300. 最长上升子序列 Golang 动态规划 贪心算法+二分查找

300. 最长上升子序列 给定一个无序的整数数组,找到其中最长上升子序列的长度。 示例: 输入: [10,9,2,5,3,7,101,18] 输出: 4 解释: 最长的上升子序列是 [2,3,7,101],它的长度是 4。 说明: 可能会有多种最长上升子序列的组合,你只需要输出对应的长度即可。 你算法的时间复杂度应该为 O(n2) 。 进阶: 你能将算法的时间复杂度降低到 O(n log n)...

Cyan1956的博客 317

求解一个序列中出现次数最多的元素贪心算法_【手绘漫画】图解LeetCode之最长上升子序列(LeetCode300题),贪心算法 + 二分查找...

图解LeetCode刷题计划1、写在前面手绘漫画系列正式上线!!!"图解LeetCode刷题计划" 来了!!!今天是第五期,争取每天一期,最多两天一期,欢迎大家监督我。。。公众号监督最好!!! 今日是贪心算法,还有好吃的~ 2、题目首先看一下题目, 应该第一时间先想到贪心算法,为什么呢?如果要使上升子序列尽可能的长,那么就要让序列上升得尽可能慢(最好一次只变化1)。因为我算法还没学完。。。动态...

weixin_39621819的博客 325

LeetCode 300.最长上升子序列(超详细)

LeetCode 300.最长上升子序列 给定一个无序的整数数组,找到其中最长上升子序列的长度。 示例: 输入: [10,9,2,5,3,7,101,18] 输出: 4 解释: 最长的上升子序列是 [2,3,7,101],它的长度是 4。 说明: 可能会有多种最长上升子序列的组合,你只需要输出对应的长度即可。 你算法的时间复杂度应该为 O(n2) 。 进阶: 你能将算法的时间复杂度降低到 ...

struct_hsj的博客 690
上一篇: LeetCode刷题: 【169】多数元素(摩尔投票法)
下一篇: LeetCode刷题: 【695】 岛屿的最大面积(深度优先搜索:递归)
ACTIM__
博客等级 码龄9年 35粉丝 105原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值