动态规划算法专题（五）：子序列问题

于 2024-10-09 05:00:00 发布
阅读量874 收藏 9
点赞数 21
分类专栏： 算法 文章标签： 算法 leetcode 开发语言 java 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83595513/article/details/142711819
版权

目录

1、最长递增子序列

1.1 算法原理

1.2 算法代码

2、摆动序列

2.1 算法原理

2.2 算法代码

 3、最长递增子序列的个数

3.1 算法原理

3.2 算法代码

4、最长数对链

4.1 算法原理

 4.2 算法代码

5、最长定差子序列

5.1 算法原理

5.2 算法代码

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

6.1 算法原理 

6.2 算法代码

7、最长等差数列

7.1 算法原理

7.2 算法代码

8、等差数列划分 II - 子序列（hard）

8.1 算法原理

8.2 算法代码

1、最长递增子序列

. - 力扣（LeetCode）

1.1 算法原理

  • 状态表示dp[i]：

以i位置为结尾的所有递增子序列中，最长递增子序列的长度

  • 状态转移方程：

dp[i]=max(dp[j]+1);// j 位于[0, i-1]区间 && nums[j] < nums[i] 

  • 初始化：

Arrays.fill(dp, 1);// 最差情况，本身

  • 建表顺序：

从左往右

  • 返回值：

dp表中的最大值 

1.2 算法代码

class Solution {
    public int lengthOfLIS(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n];
        // 初始化(最差情况: 本身)
        Arrays.fill(dp, 1);
        int ret = 1;
        // 建表
        for(int i = 1; i < n; i++) {
            // j -> [0, i-1]
            for(int j = i - 1; j >= 0; j--) {
                if(nums[j] < nums[i]) {
                    dp[i] = Math.max(dp[j] + 1, dp[i]);
                }
            }
            ret = Math.max(ret, dp[i]);
        }
        return ret;
    }
}

2、摆动序列

. - 力扣（LeetCode）

2.1 算法原理

  • 状态表示：

f[i]: 以i位置为结尾，最后呈现 上升 趋势的最长摆动序列的长度
g[i]: 以i位置为结尾，最后呈现 下降 趋势的最长摆动序列的长度

  • 状态转移方程：

f[i] = max(g[j] + 1);

g[i] = max(f[j] + 1);

  • 初始化：

f表、g表中所有元素初始化为1

  • 建表顺序：

从左往右

  • 返回值：

g表和f表中的最大值

2.2 算法代码

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int n = nums.length;
        // f[i]: 以i位置为结尾，最后呈现 上升 趋势的最长摆动序列的长度
        // g[i]: 以i位置为结尾，最后呈现 下降 趋势的最长摆动序列的长度
        int[] f = new int[n];
        int[] g = new int[n];
        // 初始化
        Arrays.fill(f, 1);
        Arrays.fill(g, 1);
        int ret = 1;
        // 填表
        for (int i = 1; i < n; i++) {
            // j -> [0, i-1]
            for(int j = i - 1; j >= 0; j--) {
                if(nums[j] > nums[i]) {
                    g[i] = Math.max(f[j] + 1, g[i]);
                }
                if(nums[j] < nums[i]) {
                    f[i] = Math.max(g[j] + 1, f[i]);
                }
            }
            ret = Math.max(ret, Math.max(g[i], f[i]));
        }
        return ret;
    }
}

 3、最长递增子序列的个数

. - 力扣（LeetCode）

3.1 算法原理

  • 状态表示：

count[i]：以i位置为结尾的所有子序列中，最长的递增子序列的 "个数"
len[i]：以i位置为结尾的所有子序列中，最长的递增子序列的 "长度"

  • 状态转移方程：

len[j]+1==len[i] --> count[i] += count[j]
len[j]+1 < len[i] --> 无视
len[j]+1 > len[i] --> count[i]=count[j] && len[i]=len[j]+1

  • 初始化：

两个表中的所有元素初始化为1（最差情况下）

  • 建表顺序：

从左往右

  • 返回值：

返回最长长度的递增子序列的"总个数"(求和)

3.2 算法代码

class Solution {
    public int findNumberOfLIS(int[] nums) {
        int n = nums.length;
        int[] len = new int[n];// 最长递增子序列的长度
        int[] count = new int[n];// 最长递增子序列的个数
        // 初始化
        Arrays.fill(len, 1);
        Arrays.fill(count, 1);
        // 最长长度 / 最大个数
        int retLen = 1, retCount = 1;
        // 填表
        for(int i = 1; i < n; i++) {
            for(int j = i - 1; j >= 0; 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(retLen == len[i]) retCount += count[i];
            else if(retLen < len[i]) {
                retLen = len[i];
                retCount = count[i];
            }
        }
        return retCount;
    }
}

4、最长数对链

. - 力扣（LeetCode）

4.1 算法原理

预处理：根据每个数对的第一个元素进行升序排序，使其满足动态规划顺序填表的规则

  • 状态表示：

dp[i]：以i位置为结尾的所有数对链中，最长数对链的 "长度"

  • 状态转移方程：

dp[i] --> j [0, i-1] --> pairs[j][1] < pairs[i][0] --> dp[i]=max(dp[j]+1 );

  • 初始化：

dp表中所有元素初始化为1

  • 建表顺序：

从左往右

  • 返回值：

dp表中的最大值

 4.2 算法代码

class Solution {
    public int findLongestChain(int[][] pairs) {
        // 预处理: 根据数对链的第一个元素进行升序排序 --> 满足动态规划顺序填表的要求
        Arrays.sort(pairs, (o1, o2) -> o1[0] - o2[0]);
        int n = pairs.length;
        int[] dp = new int[n];
        // 初始化
        Arrays.fill(dp, 1);
        int ret = 1;
        // 填表
        for(int i = 1; i < n; i++) {
            for(int j = i - 1; j >= 0; j--) {
                if(pairs[i][0] > pairs[j][1]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            ret = Math.max(ret, dp[i]);
        }
        return ret;
    }
}

5、最长定差子序列

. - 力扣（LeetCode）

5.1 算法原理

  • 状态表示：

dp[i]：以i位置为结尾的所有子序列中，最长定差子序列的 长度

  • 状态转移方程：

b=a-difference;
从前面的序列中找最后一个b(假设为j位置) --> dp[i]=dp[j]+1;

优化：哈希表
①：将元素(arr[i])和其dp值绑定，放到哈希表中
②：不用创建dp表了，直接在哈希表中进行 动态规划

③：Map天然的去重特性

  • 初始化：

每个元素的dp值初始化为1(最差情况)

  • 建表顺序：

从左往右

  • 返回值：

哈希表中最大的dp值


5.2 算法代码

class Solution {
    public int longestSubsequence(int[] arr, int difference) {
        int n = arr.length;
        // <元素, 最长长度>
        Map<Integer, Integer> hash = new HashMap<>();
        int ret = 1;
        for(int i = 0; i < n; i++) {
            // 找上一个等差值
            int b = arr[i] - difference;
            int len = hash.getOrDefault(b, 0) + 1;
            hash.put(arr[i], len);
            ret = Math.max(ret, len);
        }
        return ret;
    }
}

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

. - 力扣（LeetCode）

6.1 算法原理 

  • 状态表示：

dp[i][j]：以i位置(前)以及j位置(后)元素结尾的所有子序列中，最长的斐波那契子序列的长度

  • 状态转移方程：

j位置元素为c，i位置元素为b，k位置元素为a，则a=c-b

1. a不存在 --> 2

2. a存在，但 i<k<j --> 2

3. a存在，且合法(k<i<j) --> dp[k][i]+1;

  • 建表顺序

从上往下

  • 返回值：

dp表中的最大值
处理特殊情况：return ret == 2 ? 0 : ret ;

6.2 算法代码

class Solution5 {
    public int lenLongestFibSubseq(int[] arr) {
        int n = arr.length;
        // <元素值, 下标>
        Map<Integer, Integer> hash = new HashMap<>();
        for(int i = 0; i < n; i++) hash.put(arr[i], i);
        int[][] dp = new int[n][n];
        // 初始化
        for(int i = 0; i < n; i++) Arrays.fill(dp[i], 2);
        int ret = 0;
        // 从上往下填表
        for(int j = 2; j < n; j++) {
            for(int i = 1; i < j; i++) {
                int x = arr[j] - arr[i];
                int index = hash.getOrDefault(x, -1);
                if(index != -1 && index < i) {
                    dp[i][j] = dp[index][i] + 1;
                    ret = Math.max(ret, dp[i][j]);
                }
            }
        }
        return ret;
    }
}

7、最长等差数列

. - 力扣（LeetCode）

7.1 算法原理

  • 状态表示：

dp[i][j]：以i位置(前)和j位置(后)为结尾的所有子序列中，最长的等差数列的长度

  • 状态转移方程：

dp[i][j] = dp[k][j] + 1;（k存在且合法）

  • 初始化：

dp表中所有元素初始化为2

  • 建表顺序：

从上往下

  • 返回值：

dp表中的最大值

优化：
边做dp，边将最近的元素及其下标, 存到哈希表中：固定i，枚举j                  

7.2 算法代码

class Solution {
    public int longestArithSeqLength(int[] nums) {
        int n = nums.length;
        // dp[i][j]: 以(i, j)位置为结尾的所有子序列中,最长等差数列的长度
        int[][] dp = new int[n][n];
        // 优化 -> 将最近的元素放进哈希表中
        // <元素, 元素下标>
        Map<Integer, Integer> hash = new HashMap<>();
        hash.put(nums[0], 0);
        // 初始化
        for (int i = 0; i < n; i++) Arrays.fill(dp[i], 2);
        int ret = 2;
        // 建表(固定倒数第二个数, 枚举倒数第一个数) 
        for (int i = 1; i < n; i++) {
            for(int j = i + 1; j < n; j++) {
                int val = nums[i] * 2 - nums[j];
                int index = hash.getOrDefault(val, -1);
                if(index != -1) {
                    dp[i][j] = dp[index][i] + 1;
                    ret = Math.max(ret, dp[i][j]);
                }
            }
            hash.put(nums[i], i);
        }
        return ret;
    }
}

8、等差数列划分 II - 子序列（hard）

. - 力扣（LeetCode）

8.1 算法原理

  • 状态表示：

dp[i][j]：以i位置和j位置为结尾的所有子序列中，所有等差数列的个数

  • 状态转移方程：

a = 2*b-c

1. a不存在 --> dp[i][j] = 0
2. a存在，但不合法（k>=i） --> dp[i][j] = 0
3. a存在，且合法(k<i) --> dp[i][j] += dp[k][i]+1;(a可能重复存在，因为求的是个数，所以要全部计算)

  • 初始化：

dp表中所有值初始化为0

  • 建表顺序：

从上到下

  • 返回值：

dp表元素之和

优化：
dp前，将<元素，下标数组>绑定，存到哈希表中

8.2 算法代码

class Solution {
    public int numberOfArithmeticSlices(int[] nums) {
        int n = nums.length;
        int[][] dp = new int[n][n];
        // <元素, 下标数组>
        // Long --> 防溢出
        Map<Long, List<Integer>> hash = new HashMap<>();
        for(int i = 0; i < n; i++) {
            List<Integer> list = hash.getOrDefault((long)nums[i], null);
            if(list != null) {
                list.add(i);
            }else {
                hash.put((long)nums[i], new ArrayList<>());
                hash.get((long)nums[i]).add(i);
            }
        }
        int ret = 0;
        for(int i = 1; i < n; i++) { // 固定倒数第二个数
            for(int j = i + 1; j < n; j++) { // 枚举倒数第一个数
                long val = 2L * nums[i] - nums[j]; // 找第一个数
                List<Integer> list = hash.getOrDefault(val, null);
                if(list != null) {
                    int sum = 0;
                    for(int x : list) {
                        if(x < i) sum += dp[x][i] + 1;
                    }
                    dp[i][j] = sum;
                    ret += sum;
                }
            }
        }
        return ret;
    }
}

END

Sunrise_angel
关注
专栏目录
动态规划算法专题五--子序列问题
qq_51216031的博客
07-15 656
二是长度大于1，len[i] = max(len[j] + 1, len[i]);//j是[0, i-1]区间的位置。count[i]：表示，以i位置元素为结尾的所有递增子序列中，最长递增子序列的个数。二是长度大于1，此时i要能跟在j后面，必须满足：nums[i] > nums[j]len[i]位置记录的是最长序列长度，当i和前面的j构成的长度也等于len[i]时。len[i]：表示，以i位置元素为结尾的所有递增子序列中，最长递增子序列的长度。而是count[i] = count[j] #新的序列的个数。
【动态规划】C++算法：115.不同的子序列
闻缺陷则喜何志丹
01-05 923
给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数，结果需要对 109 + 7 取模。
【算法修炼】动态规划专题一：基本解题技巧、子序列问题、数组遍历顺序
Mxeron的博客
01-27 1041
一、动态规划基本解题技巧 学习自：https://labuladong.gitee.io/algo/3/23/71/ 1.1零钱兑换（中等） 对题目做出四点分析：base case 、状态（原问题和子问题中发生变化的变量）、选择（是什么导致状态发生了变化）、dp数组的含义 回到本题中，对于某个总金额m，它凑齐它所需的最小硬币数 = min（m - 每个硬币的面额）+ 1，当然应该判断 m - 每个硬币的面额 大于等于0，否则跳过。 因为题目说了coins是无限的，所以无论什么金额，都需要依次遍历所有的c
DP：子序列问题
2301_79969994的博客
07-02 1757
在计算机科学和数学中，子序列（Subsequence）是指从一个序列中删除一些元素（可以是零个或多个），但不改变其余元素相对顺序后形成的新序列。子序列的特点元素的相对顺序保持不变。可以删除零个或多个元素。一个序列的子序列可以为空序列，即不包含任何元素。举例说明设有序列 S = [A, B, C, D, E]，则其子序列可以有：删除零个元素：[A, B, C, D, E]（即自身）
动态规划算法专题四--子数组系列问题
qq_51216031的博客
07-11 1026
但是，如果nums[i]是一个负数，dp[i-1]是一个最大值，那么最大值×负数，直接变成最小值。长度大于1时，以i结尾，就是要包括前面i-1位置的和，即dp[i-1] + nums[i]长度大于1时，以i结尾，就是要包括前面i-1位置的和，即dp[i-1] * nums[i]长度大于1时，以i结尾，就是要包括前面i-1位置的和，即f[i-1] + nums[i]长度为1时，以i结尾，就是i位置的值，即nums[i]长度为1时，以i结尾，就是i位置的值，即nums[i]
力扣动态规划专题（五）子序列问题 不连续子序列与连续子序列 步骤及C++实现
UUUUU22的博客
06-24 1149
子序列问题 连续与不连续子序列：300.最长递增子序列、1143.最长公共子序列、1035.不相交的线。连续子序列：674.最长连续递增子序列、718. 最长重复子数组、53. 最大子序和
【算法专题】动态规划之子序列问题
YoungMLet的博客
01-27 2051
算法专题之动态规划 - - - 子序列问题（数组中不连续的一段）
【动态规划专题】最长公共子序列问题
ghscarecrow的博客
04-07 489
最长子序列问题（longest -common-subsequence problem）是一个经典的体现动态规划思想的算法问题，问题描述如下：给定两个子序列X={x1,x2,x3...xm}和Y={y1,y2,y3,...yn}。求X和Y长度最长的公共子序列。对于该问题，倘若我们使用暴力搜索法进行求解，无疑就需要穷举X的所有子序列。然后对每一个子序列检查它是否也是Y的子序列，记录找到最长的子序列。...
动态规划算法专题（四）：子串、子数组系列
2401_83595513的博客
10-08 769
DP(四)
动态规划专题之最长公共子序列1
08-08
在这个专题中，我们将深入理解动态规划在解决最长公共子序列问题上的应用。 首先，我们需要明确最长公共子序列的定义。给定两个序列X和Y，一个子序列Z是从X中抽取的元素序列，它保持原顺序但不一定连续。如果Z同时...
【算法 - 动态规划】最长回文子序列
weixin_46879314的博客
02-21 1722
样本对应模型？范围尝试模型？ 如何套路使用！
【算法 - 动态规划】最长公共子序列问题
weixin_46879314的博客
02-20 1201
动态规划 —— 样本对应模型！ 如何使用，一文搞懂套路！
【C++算法】9.双指针_四数之和
hlyd520的博客
10-04 542
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
Java 插入排序
最新发布
在那一刻，我们或许会发现自己站在了时间的另一岸，以更加成熟和宽广的胸怀，去拥抱那份隔代相传的深情。
10-08 129
插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 828
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 727
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
wnm23的专栏
10-02 801
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
生成哈夫曼树
TTz012的博客
10-08 82
例如：由叶子节点：5 15 40 30 10，生成的最优二叉树如下图所示，该树的最短带权路径长度为：40 * 1 + 30 * 2 + 5 * 4 + 10 * 4 = 205。所谓树的带权路径长度，就是树中所有的叶节点的权值乘上其到根节点的路径长度（若根节点为 0 层，叶节点到根节点的路径长度为叶节点的层数）二叉树节点中，左节点权值小于右节点权值，根节点权值为左右节点权值之和。给定长度为 n 的无序的数字数组，每个数字代表二叉树的叶子节点的权值，数字数组的值均大于等于1。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值