最少拦截系统（HDU-1257）

---

1 题意

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

---

2 思路

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

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

2.1 动态规划

  $d{p}_i$表示以第$i$个数结尾的最长递增子序列的长度。
  $d{p}_i={\max }_{j⩽i-1\wedge a_j<a_i}(a_j)+1$。
  最终要求的最长递增子序列为$ma{x}_{1⩽i⩽n}(d{p}_i)$

2.1.1 时间复杂度分析

  对于每个$d{p}_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的性质）。这里简单介绍一下算法，暂不作解释：

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

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;
}