LIS(最长上升子序列)

LIS(最长上升子序列)
如题
思路
第一种
直接开数组如果前面依次
如果前面数比它小那么以这个数为末端点的最长上升子序列等于前面那个+1
复杂度n^2

单调栈
• 从前向后扫描序列列，维护一个单调栈 h
• 设扫描到第 k 个位置，那么 h[i] 表示前 k 个位置种，选
一个长度为 i 的上升子序列列，序列列中的最后一个数最小
可以是多少，如果不存在这样子序列列，则 h[i] = inf
• 那么有 h[i] > h[i - 1]，证明可以考虑反证法
• 插入 a[k + 1] 时，我们在 h[] 中二分出一个位置 i，使得
h[i] < a[k + 1] <= h[i + 1]，令 h[i + 1] = a[k + 1] 即可

看似简单易懂但是本人太弱，二分写错了，被卡了一晚上。

int fen(int x,int l,int r){
    int mid=(l+r)>>1;
    h[1]=min(h[1],x);
    if(x<h[mid]&&x>=h[mid-1]) h[mid-1]=x;
    else if(x<h[mid-1]) fen(x,l,mid-1);
    else if(x>h[mid]) fen(x,mid,r);  
}

线段树型垃级写法（错的）

int find(int l,int r,const int& x)
{
    int mid=0;
    while(l<=r){
        mid=(l+r)/2;
        if(x>len[mid]) l=mid+1;
        else r=mid-1;
    }
    return l;
}

正确写法

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
using namespace std;
int n,len[1001],a[1001],f[1001];
int find(int l,int r,const int& x)
{
    int mid=0;
    while(l<=r){
        mid=(l+r)/2;
        if(x>len[mid]) l=mid+1;
        else r=mid-1;
    }
    return l;
}
int main()
{

    int k=0,maxlen=0;
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    for(int i=1;i<=n;i++){
        k=find(1,maxlen,a[i]);
        len[k]=a[i];
        if(maxlen<k) maxlen=k;
    }
    printf("%d",maxlen);
} 

标程
复杂度O（nlogn）

---

正确性
由于严格上升，所以要最长上升序列
所以我们在某种程度上如果后面的点影响结果必定是将原来
上升序列（长度为i）的最后一个点更新。
显然根据贪心可知，如果上升序列的末端点越小，它就有更大的变长的概率
当遍历到后面的点事，若数 比长度为i（循环） 的末端点大时它就替换这个点
因为整个要求的序列是上升的，所以发f[i]（长度为i的上升序列末端点最小值）就一定是严格上升的。
所以在更新时可以使用二分查找。

二分使复杂度降低

解法二

•首先把数组离散化，以下认为 a[] 是一个 1 ～ n 的排列列
• 扫描数组，令 b[i] 表示以数字 i 结尾的子序列最长可以
是多少
• 扫描到 a[k] 这个位置时，b[] 中只有 b[a[k]] 会改变：
• b[a[k]] = max(b[i] + 1 | i < a[k])
• 这个转移可以用树状数组维护前缀最大值

首先树状数组维护最大值只需将原来的求和变成取max
离散化
首先标号 然后排序
目的使数连续->使用树状数组（logn）
降低复杂度

我们都会这种一般的简单dp了
来看一些比较有趣的题
题目描述
“低价购买”这条建议是在奶牛股票市场取得成功的一半规则。要想被认为是伟大的投资者，你必须遵循以下的问题建议:“低价购买；再低价购买”。每次你购买一支股票,你必须用低于你上次购买它的价格购买它。买的次数越多越好!你的目标是在遵循以上建议的前提下，求你最多能购买股票的次数。你将被给出一段时间内一支股票每天的出售价(2^16范围内的正整数)，你可以选择在哪些天购买这支股票。每次购买都必须遵循“低价购买；再低价购买”的原则。写一个程序计算最大购买次数。
这里是某支股票的价格清单：
日期 1 2 3 4 5 6 7 8 9 10 11 12
价格 68 69 54 64 68 64 70 67 78 62 98 87
最优秀的投资者可以购买最多4次股票，可行方案中的一种是：
日期 2 5 6 10
价格 69 68 64 62
输入输出格式
输入格式：

第1行: N (1 <= N <= 5000)，股票发行天数
第2行: N个数，是每天的股票价格。

输出格式：

输出文件仅一行包含两个数:最大购买次数和拥有最大购买次数的方案数(<=2^31)当二种方案“看起来一样”时（就是说它们构成的价格队列一样的时候）,这2种方案被认为是相同的。

输入输出样例
输入样例#1：
BUYLOW.IN
12
68 69 54 64 68 64 70 67 78 62 98 87
输出样例#1：
BUYLOW.OUT
4 2

看完题发现最长下降子序列很好求但是难点在于求方案数
如果我们不苛求复杂度那么我们不妨使用N^2的算法
对于每个数一最普通的办法
遍历这个数之前的每一个数如i比j小那么I的子序列将大于这个点的长度
其次如果出现了重复的数字，那么这个数字清零。并顺便求出到这个数的最长不下降子序列的方案数
以下的代码很多就算看不懂我说的，这么短也一定能看懂

#include <iostream>
#include <cstdio>
#define N 5001
using namespace std;
int n,i,j,Max,ans;
int m[N],f[N],t[N];
int main ()
{
    cin>>n;
    for (i=1;i<=n;i++)
    {
        cin>>m[i];
        for (j=1;j<i;j++) 
            if (m[j]>m[i]&&f[j]>f[i])
                f[i]=f[j];
                f[i]++;
            if (f[i]==1) t[i]=1;
        for (j=1;j<i;j++) 
        if (f[i]-1==f[j]&&m[j]>m[i]) t[i]+=t[j];
        else if (m[j]==m[i]&&f[i]==f[j]) t[j]=0;
        if (f[i]>Max) Max=f[i];
    }
    ans=0;
    for (i=1;i<=n;i++) if (f[i]==Max) ans+=t[i];
    cout<<Max<<" "<<ans;
    return 0;
}