经典的序列dp问题

本文探讨如何在给定数组中找到最长递增子序列,当元素差值限制在kk范围内时,通过将朴素O(n^2)方法改进为线段树数据结构,实现在O(n log n)的时间复杂度下求解。介绍了如何利用线段树维护前缀最大值并更新dp数组。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

最长递增子序列

  • 问一个长度为 n n n的数组 a [ i ] a[i] a[i]的最长上升子序列长度
  • 这个问题非常简单了,朴素方法 O ( n 2 ) O(n^2) O(n2)的转移即可,可以二分优化到 O ( n l o g n ) O(nlogn) O(nlogn)

变形

https://leetcode.cn/problems/longest-increasing-subsequence-ii/

  • 现在加一个限制条件,要求相邻元素差值不能超过 k k k,怎么办?我们也能很简单的写出 O ( n 2 ) O(n^2) O(n2)的状态转移即设 d p [ i ] dp[i] dp[i]表示前 i i i个数的最长递增子序列,有 d p [ i ] = ( max ⁡ j < i , a [ j ] < a [ i ] , a [ i ] − a [ j ] ≤ k d p [ j ] ) + 1 dp[i]=(\max\limits_{j<i,a[j]<a[i],a[i]-a[j]\leq k}dp[j])+1 dp[i]=(j<i,a[j]<a[i],a[i]a[j]kmaxdp[j])+1,但是这里 a [ i ] a[i] a[i] n n n的范围都是 [ 1 , 1 0 5 ] [1,10^5] [1,105],所以寻找前缀最大值的时候需要 O ( l o g n ) O(logn) O(logn)的时间复杂度,考虑使用线段树维护前缀值域,每次找最大的一个,然后更新当前值,因为同一个值新的必然比旧的更优
class Solution{
  int mx;
  // 线段树维护[l, r]满足条件的最大子序列长度
  vector<int> segtree;
public:
  int query(int o, int l, int r, int ql, int qr){
    if(ql > r || qr < l) return 0;
    if(ql <= l && r <= qr){
      return segtree[o];
    }
    int ans = 0;
    int mid = ((r - l) >> 1) + l;
    if(ql <= mid){
      ans = max(ans, query(o << 1, l, mid, ql, qr));
    }
    if(mid < qr){
      ans = max(ans, query(o << 1 | 1, mid + 1, r, ql, qr));
    }
    return ans;
  }
  void modify(int o, int l, int r, int p, int val){
    if(l == r){
      segtree[o] = max(segtree[o], val);
      return;
    }
    int mid = ((r - l) >> 1) + l;
    if(p <= mid){
      modify(o << 1, l, mid, p, val);
    }else{
      modify(o << 1 | 1, mid + 1, r, p, val);
    }
    segtree[o] = max(segtree[o << 1], segtree[o << 1 | 1]);
  }
  int lengthOfLIS(vector<int>& nums, int k) {
    int n = (int)nums.size();
    int ans = 0;
    mx = *max_element(nums.begin(), nums.end());
    segtree.resize(4 * mx + 1);
    for(int i=0;i<n;i++){
      int x = 1;
      if(nums[i] != 1){
        x = query(1, 1, mx, max(1, nums[i] - k), nums[i] - 1) + 1;
      }
      ans = max(ans, x);
      modify(1, 1, mx, nums[i], x);
    }
    return ans;
  }
};
### 子序列动态规划算法详解 #### 定义与特性 动态规划(Dynamic Programming, DP)是一种通过将复杂问题分解为更小的子问题来求解的方法,特别适用于具有最优子结构和重叠子问题性质的问题[^3]。对于最长公共子序列(Longest Common Subsequence, LCS)这类问题动态规划能够有效地找到两个或多个字符串之间的最长共同部分。 #### 最长公共子序列 (LCS) 的定义 给定两个序列 X 和 Y,如果存在一个严格递增下标的整数序列 i_1 < i_2 < ... < i_k 及 j_1 < j_2 < ... < j_k 使得 Xi_{m} = Yj_{m}, 则称此序列为X和Y的一个公共子序列。而其中长度最大的称为这两个序列的最长公共子序列[LCS][^1]. #### 动态规划解决 LCS 问题的过程 为了利用动态规划解决问题,需要构建一张二维表格 c[i,j], 表示Xi到第i个字符为止,Yj到第j个字符为止的最大匹配数目: - 当 `X[i]=Y[j]` 时,则有 `c[i][j]=c[i−1][j−1]+1`; - 否则取较大者作为当前格子的结果:`max(c[i−1][j],c[i][j−1])`. 最终答案即为表中的最后一个元素值 c[m,n]. 这样做不仅解决了问题本身还记录下了路径以便回溯打印具体的方案. ```cpp #include<iostream> using namespace std; void lcs( char *X ,char *Y,int m,int n ) { int L[m+1][n+1]; for(int i=0;i<=m;i++) for(int j=0;j<=n;j++){ if(i==0 || j==0) L[i][j]=0; else if(X[i-1]==Y[j-1]) L[i][j]=L[i-1][j-1]+1; else L[i][j]=max(L[i-1][j],L[i][j-1]); } } ``` 上述代码展示了如何使用 C++ 来实现寻找两串字符间的最大公共子序列的功能[^2]. #### 关键概念解释 - **最优子结构性质**: 如果一个问题可以被分割成几个较小规模相同类型的子问题,并且这些子问题之间可能存在依赖关系,那么这个问题就具备了所谓的“最优子结构性质”。这意味着可以通过组合各个子问题的最佳解决方案来获得整个问题的整体最佳解答。 - **重叠子问题属性**: 在某些情况下,在尝试用递归来解决问题的过程中可能会遇到相同的子问题反复出现的情况。为了避免不必要的重复工作,我们可以采用记忆化技术或者自底向上的迭代方式预先存储那些已经被处理过的小型实例的答案,以此加快整体运算速度并减少资源消耗。 - **状态转移方程**: 描述了从已知条件出发逐步推导未知情况变化规律的一种表达形式。它明确了每一个阶段的状态是如何从前一阶段演变而来以及两者间存在着怎样的联系。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Clarence Liu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值