dp——最长上升子序列(LIS)

问题描述

最长上升子序列LIS(longest increasing subsequence):给定一个长度为n的序列

(a1,a2,a3,...,an) 
a1<a2<a3<...<an

 从中选取一个子序列,这个子序列需要单调递增。

问最长上升子序列(LIS)的长度。

eg:1, 5, 2, 4, 11, 7, 9

其中的一些上升子序列为{1,5},{1,2} ... 

则LIS序列为:1,2,4,7,9, 长度为5.

设计状态

记f(x)为以a[x]结尾的LIS长度,那么LIS=max{f(x)}.

如何推导f(x),f(x)从哪来呢?

考虑比x小的每一个 j,如果a[x] > a [j],那么f(x) = f(j)+1;

状态转移方程

f(x)=max{f(j)}+1(j<x,则a[j]<a[x])

我们以Leetcode上的一道题目为例子,https://leetcode-cn.com/problems/longest-palindromic-substring/

采用动态规划的方式来做,

状态设计:dp[i]代表以序列a[i]为结尾的长度

状态转移:dp[i] = max{dp[i], dp[j]+1}(0<=j<i, a[j]<a[i])

边界:dp[i]=1(0<=j<n)

时间复杂度:O(N^2)

例题中输入的子序列为

10,9,2,5,3,7,101,18

输出:4

解释:最长上升子序列是{2, 3, 7, 101}, 它的长度为4

dp[i]初始值j=0j=1j=2j=3j=4j=5j=6
dp[0]1       
dp[1]11      
dp[2]111     
dp[3]1112    
dp[4]11122   
dp[5]111233  
dp[6]1222334 

下面是参考例子

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
         
        if (size == 0) return 0;    //检查输入的数组是否合法
        int size=(int)nums.size();
        int ans=1;
        vector<int> dp(size, 0);
        for (int i = 0; i < size; ++i) {    //从头遍历子序列到终点
            dp[i] = 1;
            for (int j = 0; j < i; ++j) {
                if (nums[j] < nums[i]) {
                    dp[i] = max(dp[i], dp[j] + 1);    //状态转移
                }                
            }
            ans=max(ans, dp[i]);                    //比较每一个dp,最大值为答案
        }
        return ans;
    }
};

/******
* 10,9,2,5,3,7,101,18
* 2,3,7,101
* 4
*/

 

### 动态规划解决最长上升子序列问题 #### 定义与目标 最长上升子序列(Longest Increasing Subsequence, LIS)是在一个给定的无序数组中,找出一个最长的子序列,该子序列中的元素严格递增。需要注意的是,这个子序列不需要是连续的。 对于这个问题,可以采用动态规划的方法来求解其长度。通过定义 `dp[i]` 表示以第 `i` 个元素结尾的最长上升子序列的长度[^2]。 --- #### 动态规划的核心思路 为了计算每一个位置上的最优解,我们需要遍历之前的元素并更新当前状态: 1. 初始化:令所有的 `dp[i] = 1`,因为最短的情况下,每个单独的元素本身就是一个长度为 1 的上升子序列。 2. 转移方程: 对于任意两个索引 `j < i`,如果满足条件 `arr[j] < arr[i]`,则有: \[ dp[i] = \max(dp[i], dp[j] + 1) \] 这表示将以 `arr[j]` 结尾的子序列扩展到 `arr[i]` 上形成新的更长的子序列。 3. 最终结果:整个数组的最大值即为所求的最长上升子序列的长度: \[ \text{result} = \max_{0 \leq i < n}(dp[i]) \] 这种方法的时间复杂度为 \(O(n^2)\),其中 \(n\) 是输入数组的大小。 --- #### C++代码实现 以下是基于上述方法的一个完整的C++程序实现: ```cpp #include <iostream> #include <vector> #include <algorithm> using namespace std; int lengthOfLIS(vector<int>& nums) { if (nums.empty()) return 0; int n = nums.size(); vector<int> dp(n, 1); // 初始状态下,每个元素都至少构成长度为1的子序列 for(int i = 1; i < n; ++i){ for(int j = 0; j < i; ++j){ if(nums[j] < nums[i]){ dp[i] = max(dp[i], dp[j]+1); } } } return *max_element(dp.begin(), dp.end()); // 返回最大值作为最终的结果 } // 测试函数 void test(){ vector<int> sequence = {2, 3, 4, 1, 5, 8, 6}; cout << "The Length of Longest Increasing Subsequence is: " << lengthOfLIS(sequence) << endl; } int main() { test(); return 0; } ``` 此代码实现了基本的动态规划解决方案,并测试了一个样例数据集 `{2, 3, 4, 1, 5, 8, 6}`,输出应为 `5`,对应于可能的子序列 `[2, 3, 4, 5, 6]` 或者 `[2, 3, 4, 5, 8]`[^4]。 --- #### 更高效的算法 —— O(n log n) 尽管上面提到的动态规划方法简单直观,但它的时间复杂度较高 (\(O(n^2)\))。一种更为高效的方式利用二分查找配合贪心策略可以在 \(O(n \log n)\) 时间内完成相同任务。 核心思想在于维护一个辅助列表 `tails[]` 来记录潜在候选者的最小结束数值。每当遇到新数时,我们尝试将其放置在合适的位置替换掉旧值或将它追加至末尾。 具体步骤如下: - 遍历原数组; - 使用二分查找定位应该插入的新位置; - 更新或扩充 `tails[]` 数组。 这种改进版本不仅保持了正确性还显著提升了性能表现。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值