子序列问题

最新推荐文章于 2023-06-14 17:31:49 发布
最新推荐文章于 2023-06-14 17:31:49 发布
阅读量142 收藏
点赞数
分类专栏： 数据结构 文章标签： 动态规划 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44761821/article/details/120388205
版权

子序列 是值 一个字串 中 非连续 的 字串 ；字串： 123456789 子序列a： 13579（非连续）

字串b ： 12345（连续）

** 子串 问题

** 1.求最大子串 **
class Solution {
public int lengthOfLIS(int[] nums) {

    int get=vector(nums,0,nums.length-1);

    return get;
}
//就最大子串
public int vector(int[] nums,int begin,int end){
    int max=0;//输出最大子串的和
    int curr=0;
    int newBegin=0;

for(int i=0; i <nums.length  ;  i++){
    curr += nums[i];
    if(curr > max)
    {
        max=curr;
        begin =newBegin;
        end=i;
    }
        
    if(curr < 0)
    {
        curr=0;
        newBegin=i+1;
    }
}
return  max;
}

}
// 找 最大子序列的 方法很简单 ，只要前 i 项 的和 还没有 小于 0 那么 子序列 就 一直向后扩展
// 小于 0 就 丢弃之前的 子序列 并且开始 新的 子序列

** 2.最长公共子串 **

**

** 子序列问题 **

首先让们想一下，有一个字串A：1 2 3 4 5 6 7 8 9，我们将它放在一个数组B里面，从B[0]开始放，
有一个数组f[9]用来记录字串从1到9的每个数的递增数；比如说：f[4]里面放的就是到5的最长递增数，f[4]的值就是5；现在我们想想这个数是怎么得到的，是不是依次将f[0]到f[3]的大小比较一遍，选出其中一个最大的数+1赋值给f[4]；同时别忘了要满足B[4]>B[3]。现在让我们来实现我所说的这段话的代码。

1.递推法 解决 最长递增子序列问题
(不推荐）
int list(float[] B）
{
int n=B.length;
int[] f=new int[n];
f[0]=1;
for(int i=1; i< n; i++)
{
f[i] =1;
for(int j=0 ; j <i ; j++){
if(B[j] < B[i] && f[j] > f[i]-1 )
//作用是 比大小然后满足递增
f[i]=f[j]+1;
}
}
return f[n-1];
}

一， 最长递增子序列问题的描述

在这里插入图片描述

在这里插入图片描述

dp[i]：[0, i] 的最长上升子序列的长度。

dp[i] ： 以 nums【i】 结尾 的 子序列 ，能达到 的 最大长度。

对于 dp【i】 来说，只要 找到 前面 比 nums【i】 小 的 nums【j】 中 最大 的 dp【j】即可。

动态转移方程
dp[i] = max(dp[i], dp[j] + 1); nums[i] > nums[j]
为啥你能得出这个方程？
首先要知道，如果 nums[i] 严格大于在它之前的某个数，那么 nums[i] 就可以接在这个数后面，形成一个更长的上升子序列。
所以我们每次都要在 [0, i) 这个区间内去找。那么定义 j，然后在 [0,i) 区间去找比 num[i] 小的数。区分为两种情况：

当 nums[i] > nums[j] ：上升趋势，符合题意，dp[j] + 1;
当 nums[i] <= nums[j] ：非上升趋势，不符合题意，跳过。
上述所有 1. 情况 下计算出的 dp[j] + 1 的最大值，为直到 i 的最长上升子序列长度（dp[i]）。实现方式为遍历 j 时，每轮执行 dp[i] = max(dp[i], dp[j] + 1)。
初始化：
数组中每个元素都至少可以单独成为子序列，长度最少都为 1，所以初始化全为 1。

class Solution {
public int lengthOfLIS(int[] nums) {

	int len =nums.length;
	int ans=1;
	//dp[i]  ： 以 nums【i】 结尾 的 子序列  ，能达到 的 最大长度。
	int dp[] = new int[len];
	
	//边界
	dp[0] =1；

	//复杂度（n的平方）
	for(int i=1 ;i < len  ; i++ )
	{
	  dp[i]=1;
		//找到前面结点里，比  num是【i】 小 的中，dp[] 最长的值
		int maxPre=0;
		for(int j= i-1 ;j>=0 ; j--）
			{
				if ( num[i] > nums[j] {
					//dp【j】最优子结构  例如 ： 数组 1 2 3 4  i为3  j为 0 1 2  求出 j中的最大值
					maxPre=Math.max( dp[j], maxPre);
				}
			}
	}
 	//状态转移方程
 	dp[i] = maxPre +1;
 	ans= Math.max(ans,dp[i]);
}
return ans;

}

复杂度分析

时间复杂度：O(n^2)
)，其中 nn 为数组 nums 的长度。动态规划的状态数为 n，计算状态 dp[i] 时，需要 O(n) 的时间遍历 dp[0 … i-1] 的所有状态，所以总时间复杂度为 O(n^2)。

空间复杂度：O(n)，需要额外使用长度为 nn 的 dpdp 数组。

** 动态规划 + 二分法 + 贪心O（nlogn） **

public class Solution {
public int lengthOfLIS(int[] nums) {
int len = nums.length;
if (len <= 1) {
return len;
}

    // tail 数组的定义：长度为 i + 1 的上升子序列的末尾最小是几
    int[] tail = new int[len];
    // 遍历第 1 个数，直接放在有序数组 tail 的开头
    tail[0] = nums[0];
    // end 表示有序数组 tail 的最后一个已经赋值元素的索引
    int end = 0;

    for (int i = 1; i < len; i++) {
        // 【逻辑 1】比 tail 数组实际有效的末尾的那个元素还大
        if (nums[i] > tail[end]) {
            // 直接添加在那个元素的后面，所以 end 先加 1
            end++;
            tail[end] = nums[i];
        } else {
            // 使用二分查找法，在有序数组 tail 中
            // 找到第 1 个大于等于 nums[i] 的元素，尝试让那个元素更小
            int left = 0;
            int right = end;
            while (left < right) {
                // 选左中位数不是偶然，而是有原因的，原因请见 LeetCode 第 35 题题解
                // int mid = left + (right - left) / 2;
                int mid = left + ((right - left) >>> 1);
                if (tail[mid] < nums[i]) {
                    // 中位数肯定不是要找的数，把它写在分支的前面
                    left = mid + 1;
                } else {
                    right = mid;
                }
            }
            // 走到这里是因为 【逻辑 1】 的反面，因此一定能找到第 1 个大于等于 nums[i] 的元素
            // 因此，无需再单独判断
            tail[left] = nums[i];
        }
        // 调试方法
        // printArray(nums[i], tail);
    }
    // 此时 end 是有序数组 tail 最后一个元素的索引
    // 题目要求返回的是长度，因此 +1 后返回
    end++;
    return end;
}

// 调试方法，以观察是否运行正确
private void printArray(int num, int[] tail) {
    System.out.print("当前数字：" + num);
    System.out.print("\t当前 tail 数组：");
    int len = tail.length;
    for (int i = 0; i < len; i++) {
        if (tail[i] == 0) {
            break;
        }
        System.out.print(tail[i] + ", ");
    }
    System.out.println();
}

public static void main(String[] args) {
    int[] nums = new int[]{3, 5, 6, 2, 5, 4, 19, 5, 6, 7, 12};
    Solution solution = new Solution8();
    int lengthOfLIS = solution8.lengthOfLIS(nums);
    System.out.println("最长上升子序列的长度：" + lengthOfLIS);
}

}

作者：liweiwei1419
链接：https://leetcode-cn.com/problems/longest-increasing-subsequence/solution/dong-tai-gui-hua-er-fen-cha-zhao-tan-xin-suan-fa-p/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

在这里插入图片描述

  1. 确定dp数组（dp table）以及下标的含义
    这道题目我们要一起维护两个数组。

dp[i]：i之前（包括i）最长递增子序列的长度为dp[i]

count[i]：以nums[i]为结尾的字符串，最长递增子序列的个数为count[i]

  1. 确定递推公式
    在300.最长上升子序列 中，我们给出的状态转移是：

if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);

即：位置i的最长递增子序列长度 等于j从0到i-1各个位置的最长升序子序列 + 1的最大值。

本题就没那么简单了，我们要考虑两个维度，一个是dp[i]的更新，一个是count[i]的更新。

那么如何更新count[i]呢？

以nums[i]为结尾的字符串，最长递增子序列的个数为count[i]。

那么在nums[i] > nums[j]前提下，如果在[0, i-1]的范围内，找到了j，使得dp[j] + 1 > dp[i]，说明找到了一个更长的递增子序列。

那么以j为结尾的子串的最长递增子序列的个数，就是最新的以i为结尾的子串的最长递增子序列的个数，即：count[i] = count[j]。

在nums[i] > nums[j]前提下，如果在[0, i-1]的范围内，找到了j，使得dp[j] + 1 == dp[i]，说明找到了两个相同长度的递增子序列。

那么以i为结尾的子串的最长递增子序列的个数 就应该加上以j为结尾的子串的最长递增子序列的个数，即：count[i] += count[j];

代码如下：

if (nums[i] > nums[j]) {
if (dp[j] + 1 > dp[i]) {
count[i] = count[j];
} else if (dp[j] + 1 == dp[i]) {
count[i] += count[j];
}
dp[i] = max(dp[i], dp[j] + 1);
}
当然也可以这么写：

if (nums[i] > nums[j]) {
if (dp[j] + 1 > dp[i]) {
dp[i] = dp[j] + 1; // 更新dp[i]放在这里，就不用max了
count[i] = count[j];
} else if (dp[j] + 1 == dp[i]) {
count[i] += count[j];
}
}
这里count[i]记录了以nums[i]为结尾的字符串，最长递增子序列的个数。dp[i]记录了i之前（包括i）最长递增序列的长度。

题目要求最长递增序列的长度的个数，我们应该把最长长度记录下来。

代码如下：

for (int i = 1; i < nums.size(); i++) {
for (int j = 0; j < i; j++) {
if (nums[i] > nums[j]) {
if (dp[j] + 1 > dp[i]) {
count[i] = count[j];
} else if (dp[j] + 1 == dp[i]) {
count[i] += count[j];
}
dp[i] = max(dp[i], dp[j] + 1);
}
if (dp[i] > maxCount) maxCount = dp[i]; // 记录最长长度
}
}
3. dp数组如何初始化
再回顾一下dp[i]和count[i]的定义

count[i]记录了以nums[i]为结尾的字符串，最长递增子序列的个数。

那么最少也就是1个，所以count[i]初始为1。

dp[i]记录了i之前（包括i）最长递增序列的长度。

最小的长度也是1，所以dp[i]初始为1。

代码如下：

vector dp(nums.size(), 1);
vector count(nums.size(), 1);
其实动规的题目中，初始化很有讲究，也很考察对dp数组定义的理解。

  1. 确定遍历顺序
    dp[i] 是由0到i-1各个位置的最长升序子序列 推导而来，那么遍历i一定是从前向后遍历。

j其实就是0到i-1，遍历i的循环里外层，遍历j则在内层，代码如下：

for (int i = 1; i < nums.size(); i++) {
for (int j = 0; j < i; j++) {
if (nums[i] > nums[j]) {
if (dp[j] + 1 > dp[i]) {
count[i] = count[j];
} else if (dp[j] + 1 == dp[i]) {
count[i] += count[j];
}
dp[i] = max(dp[i], dp[j] + 1);
}
if (dp[i] > maxCount) maxCount = dp[i];
}
}
最后还有再遍历一遍dp[i]，把最长递增序列长度对应的count[i]累计下来就是结果了。

代码如下：

for (int i = 1; i < nums.size(); i++) {
for (int j = 0; j < i; j++) {
if (nums[i] > nums[j]) {
if (dp[j] + 1 > dp[i]) {
count[i] = count[j];
} else if (dp[j] + 1 == dp[i]) {
count[i] += count[j];
}
dp[i] = max(dp[i], dp[j] + 1);
}
if (dp[i] > maxCount) maxCount = dp[i];
}
}
int result = 0; // 统计结果
for (int i = 0; i < nums.size(); i++) {
if (maxCount == dp[i]) result += count[i];
}
统计结果，可能有的同学又有点看懵了，那么就再回顾一下dp[i]和count[i]的定义。

  1. 举例推导dp数组
    输入：[1,3,5,4,7]

如果代码写出来了，怎么改都通过不了，那么把dp和count打印出来看看对不对！

时间复杂度O(n^2)
空间复杂度O(n)
还有O(nlogn)的解法，使用树状数组，今天有点忙就先不写了，感兴趣的同学可以自行学习一下，这里有我之前写的树状数组系列博客 （十年前的陈年老文了）

class Solution {
public int findNumberOfLIS(int[] nums) {
if (nums.length <= 1) return nums.length;
int[] dp = new int[nums.length];
for(int i = 0; i < dp.length; i++) dp[i] = 1;
int[] count = new int[nums.length];
for(int i = 0; i < count.length; i++) count[i] = 1;

    int maxCount = 0;
    for (int i = 1; i < nums.length; i++) {
        for (int j = 0; j < i; j++) {
            if (nums[i] > nums[j]) {
                if (dp[j] + 1 > dp[i]) {
                    dp[i] = dp[j] + 1;
                    count[i] = count[j];
                } else if (dp[j] + 1 == dp[i]) {
                    count[i] += count[j];
                }
            }
            if (dp[i] > maxCount) maxCount = dp[i];
        }
    }
    int result = 0;
    for (int i = 0; i < nums.length; i++) {
        if (maxCount == dp[i]) result += count[i];
    }
    return result;
}

}

作者：carlsun-2
链接：https://leetcode-cn.com/problems/number-of-longest-increasing-subsequence/solution/dai-ma-sui-xiang-lu-dai-ni-xue-tou-dp673-9txt/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

在这里插入图片描述

MZR--JAVA
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode系列354—俄罗斯套娃信封问题
fkuner的博客
11-20 293
题意 给定一些标记了宽度和高度的信封，宽度和高度以整数对形式 (w, h) 出现。当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。 请计算最多能有多少个信封能组成一组“俄罗斯套娃”信封（即可以把一个信封放到另一个信封里面）。 说明：不允许旋转信封。 示例： 输入: envelopes = [[5,4],[6,4],[6,7],[2,3]] 输出: 3 解释: 最多信封的个数为 3, 组合为: [2,3] => [5,4] => [6,7]。
动态规划---子序列问题
weixin_61518137的博客
07-18 479
2.3)先找到以j位置为结尾的最长递增子序列的长度，并且array[i]>array[j]，然后再加上array[j]的值，就构成了以i为结尾的最长递增子序列。1)f[i]表示以i位置元素为结尾的所有子序列中，最后一个位置呈现上升趋势的最长的摆动序列的长度。2)g[i]表示以i位置元素为结尾的所有子序列中，最后一个位置呈现下降趋势的最长的摆动序列的长度。中心思路就是找到以i位置为结尾的所有递增子序列，然后找到递增子序列中最长的一个子序列。dp[i]表示，以i位置为结尾，最长递增子序列的长度。
动态规划——子序列问题——连续？不连续？
getinobacar的博客
03-03 5199
动态规划——子序列问题——连续？不连续？ 子序列问题是动态规划的一个常考题型，本篇文章主要介绍 子序列（连续）和子序列（不连续）两个问题。连续和不连续指的是子序列是否是连续的，还是说中间是可以有间隔的子序列。 一：子序列（不连续） 300. 最长递增子序列 分析：从题意我们可以读出该题想求的是不连续的递增子序列。 解法：动态规划 第一步：dp[i]的定义 dp[i]表示i之前包括i的最长上升子序列的长度。 第二步：状态转移方程 位置 i 的最长升序子序列等于 j 从 0..
数据结构与算法--子序列问题
我会微积分
10-11 247
1.最长上升子序列 leetcode300
子序列问题详解
LJIONG的博客
03-18 1126
线性动态规划——子序列问题 （有错误欢迎指出，部分解法灵感来源于洛谷题解） 文章目录线性动态规划——子序列问题1.最长上升子序列（LIS，Longest Increasing Subsequence）1.1 动态规划1.1.1 状态转移方程1.1.2 时间复杂度1.1.3 代码1.2树状数组优化1.2.1 思路1.2.2 时间复杂度1.2.3 具体操作1.2.4 代码2.其他子序列问题2.1 最长...
最长公共子序列问题.docx
06-14
字符序列的子序列是指从给定字符序列中随意地（不一定连续）去掉若干个字符（可能一个也不去掉）后所形成的字符序列。令给定的字符序列X=（x0，x1，…，xm-1），序列Y...该问题是求两序列A和B的最长公共子序列（LCS）。
求解最长公共子序列问题LCSlength(debug).cpp
05-08
【问题描述】字符序列的子序列是指从给定字符序列中随意地（不一定要联系）去掉若干个字符（可能一个也不去掉）后所形成的字符序列。给定两个序列A和B，称序列Z是A和B的公共子序列，是指Z同是A和B的子序列，该问题是...
最长公共子序列问题最长公共子序列问题
10-14
一个给定序列的子序列是在该序列中删去若干元素后得到的序列。确切地说，若给定序列X= { x1, x2,…, xm}，则另一序列Z= {z1, z2,…, zk}是X的子序列是指存在一个严格递增的下标序列 {i1, i2,…, ik}，使得对于所有j=...
c++语言写最长公共子序列问题
07-07
C++ 语言写最长公共子序列问题 C++ 语言写最长公共子序列问题是动态规划的经典问题之一。本问题的核心思想是通过比较两个序列，找出它们之间的公共子序列，并输出该公共子序列的长度和内容。 动态规划（Dynamic ...
基于C++实现编辑距离问题、货物堆积问题、骑士周游问题、数组分割问题、资源分配问题、最长上升子序列问题
04-12
这些问题是编辑距离问题、货物堆积问题、骑士周游问题、数组分割问题、资源分配问题以及最长上升子序列问题。我们将逐一深入探讨这些知识点。 1. **编辑距离问题**： 编辑距离（Levenshtein Distance）是衡量两个...
动态规划算法（子序列专题1）
m0_52882232的博客
06-14 1692
子数列，又称子序列，在数学中，某个序列的子序列是从最初序列通过去除某些元素但不破坏余下元素的相对位置（在前或在后）而形成的新序列。例如，[3,6,2,7]是数组的子序列。下面我们将通过几道经典例题来进行讲述根据经验+题目要求，我们可以得到如下定义：dp[i]表示，以下标i元素为结尾的递增子序列的最长长度根据题目+经验，dp[i]表示：以i为结尾的斐波那契式的子序列的最长的长度状态分析：新的状态定义：dp[i] [j]表示：以i及j位置为结尾的斐波那契式子序列的最长的长度（i<j）
【LeetCode题解】子序列问题
hxf_fxh的博客
10-27 386
128 最长连续序列 #128 最长连续序列 给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。 请你设计并实现时间复杂度为 O(n) 的算法解决此问题。 示例 1： 输入：nums = [100,4,200,1,3,2] 输出：4 解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。 示例 2： 输入：nums = [0,3,7,2,5,8,4,6,0,1] 输出：9 思路 使用一个哈希表进行去重，同时将nums的元素都放入哈希表中，这样
动态规划——子序列问题
Psychosocial的博客
04-14 2160
一、最长上升子序列（LIS） 1、输出长度 问题描述： 一个数的序列bi，当b1<b2<…<bS的时候，我们称这个序列是上升的。比如，对于序列(1,7,3,5,9,4,8)，有它的一些上升子序列，如(1,7),(3,4,8)等等。这些子序列中最长的长度是4，比如子序列(1,3,5,8)。 你的任务，就是对于给定的序列，求出最长上升子序列的长度。 输入 输入的第一行是序列的长度N...
【LeetCode每日一题】673. 最长递增子序列的个数
m0_46753549的博客
09-21 117
673. 最长递增子序列的个数题目示例关键思路代码实现运行结果总结反思链接 题目 给定一个未排序的整数数组，找到最长递增子序列的个数。 示例 示例1 输入： [1,3,5,4,7] 输出： 2 解释： 有两个最长递增子序列，分别是 [1, 3, 4, 7] 和[1, 3, 5, 7]。 示例2 输入：[2,2,2,2,2] 输出：5 解释： 最长递增子序列的长度是1，并且存在5个子序列的长度为1，因此输出5。 关键思路 使用动态规划思想解决，本题为原题的升级版，可以一边求解dp，一边计算当前
【LeetCode 动态规划专项】最长递增子序列的个数（673）
weixin_37780776的博客
09-12 323
【LeetCode 动态规划专项】最长递增子序列的个数（673）
最大子序列问题_C++
baidu_39049318的博客
09-16 282
最大子序列问题 描述：给定整数 A1,A2,⋯ ,ANA_1, A_2, \cdots, A_NA1​,A2​,⋯,AN​ （可能有负数），求 Σk=ijAk\Sigma_{k=i}^j A_kΣk=ij​Ak​ 的最大值（如果所有整数均为负数，则最大子序列和为0） 例： 输入：-2， 11， -4， 13， -5， -2 输出：20 递归分治思想 考虑最大子序列只可能有三种可能，出现在序列的左半部分、右半部分或者跨越左右两半部分。前两种情况可以通过递归的方法实现，递归停止条件为左边界等于右边界，即只有一个
【动态规划】子序列问题
一只禾的博客
02-14 324
子序列问题也是有一堆题目的问题。 300. 最长递增子序列 - 力扣（LeetCode） (leetcode-cn.com) 依次解决： 1.【300】最长递增子序列 300. 最长递增子序列 - 力扣（LeetCode） (leetcode-cn.com) 1.1.动态规划法 老老实实双层循环法。 时间复杂度：O(n^2) 空间复杂度：O(n) 代码如下： class Solution(object): def lengthOfLIS(self, nums):
最长公共子序列问题 python
最新发布
05-30
最长公共子序列问题是指，给定两个序列，找到它们之间最长的公共子序列。子序列指的是从原序列中删除任意个元素后得到的新序列。因此，最长公共子序列问题就是要在两个给定序列中找到一个最长的子序列，使得这个子...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值