最少拦截系统（HDU-1257）

最新推荐文章于 2023-10-27 19:24:16 发布

cjmHK

最新推荐文章于 2023-10-27 19:24:16 发布

阅读量1.8k

点赞数 2

分类专栏：动态规划单调栈文章标签：算法

本文链接：https://blog.csdn.net/qq_40634175/article/details/82831898

版权

动态规划同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

单调栈

2 篇文章 0 订阅

订阅专栏

1 题意

将数列 $\left\{ a_{n} \right\}$ 划分成若干个非递增子序列，求最小划分数。
链接：link。

2 思路

命题1：数列 $\left\{ a_{n} \right\}$ 非递增子序列的最小划分数等于其最长递增子序列的长度。
证明：
设数列 $\left\{ a_{n} \right\}$ 非递增子序列的最小划分数为k，数列 $\left\{ a_{n} \right\}$ 最长递增子序列的长度为p。
显然最长递增子序列中不可能有两个数在同一个划分里面，所以有 $\geqslant p$ 。
其次，可以在每个划分里面拿出一个数出来，构成一个递增子序列（这里暂时不解释），这样 $\leqslant p$ 。
综上可推出 $k = p$ 。

命题2：数列 $\left\{ a_{n} \right\}$ 递增子序列的最小划分数等于其最长非递增子序列的长度。
命题3：数列 $\left\{ a_{n} \right\}$ 非递减子序列的最小划分数等于其最长递减子序列的长度。
命题4：数列 $\left\{ a_{n} \right\}$ 递减子序列的最小划分数等于其最长非递减子序列的长度。

2.1 动态规划

$dp_{i}$ 表示以第 $i$ 个数结尾的最长递增子序列的长度。
$dp_{i}= \max_{j \leqslant i-1 \wedge a_{j} < a_{i}}(a_{j})+1$ 。
最终要求的最长递增子序列为 $max_{1 \leqslant i \leqslant n}(dp_{i})$

2.1.1 时间复杂度分析

对于每个 $dp_{i}$ 都需要在 $[1, i - 1]$ 中寻找最优解，所以时间复杂度为 $\mathcal{O}(n^{2})$ 。

2.1.2 实现

#include<iostream>
#include<cstdio>
using namespace std;
const int N=1e3+10;
int a[N],dp[N],n;
int main(){
    while(~scanf("%d",&n)){
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        int res=0;
        for(int i=1;i<=n;i++){
            dp[i]=1;
            for(int j=1;j<i;j++){
                if(a[j]<a[i]){
                    dp[i]=max(dp[i],dp[j]+1);
                }
            }
            res=max(res,dp[i]);
        }
        printf("%d\n",res);
    }
    return 0;
}

2.2 单调栈

最长递增子序列也可以通过"单调栈"实现（事实上这不是真正意义上的单调栈，因为在操作过程中修改了栈中间的元素，破坏了FIFO的性质）。这里简单介绍一下算法，暂不作解释：

对于每个需要入栈的元素，比较其与栈顶元素的大小
如果栈为空或比栈顶元素大，则直接入栈
否则，用其替换栈内第一个大于或等于他的元素

2.2.1 时间复杂度分析

最坏的情况下，每次的入栈元素都需要替换，替换过程中使用二分查找，时间复杂度为 $\mathcal{O}{log(n)}$ 。
总的时间复杂度为 $\mathcal{O}(nlog(n))$

2.2.2 实现

#include<iostream>
#include<cstdio>
#include<vector>
using namespace std;
int n;
int main(){
    while(~scanf("%d",&n)){
        vector<int> stk;
        for(int i=1;i<=n;i++){
            int val;scanf("%d",&val);
            if(stk.empty()||stk.back()<val) stk.push_back(val);
            else *lower_bound(stk.begin(),stk.end(),val)=val;
        }
        printf("%d\n",stk.size());
    }
    return 0;
}