一道题

n<=100000个<=100000的正数，其中有一些0表示这个位置的数字可以是L~R中的一个，L，R是给定常数且1<=L<=R<=100000，问最长上升子序列。

先暴力啊！$f(i,j)$表示前i个数中以j结尾的答案。$f(i,j)=f(i-1,j)$，$f(i,a_i)=max(f(i-1,j)+1),j<a_i$为$a_i$>0的转移方式，而$f(i,j)=max(f(i-1,k)+1),L<=j<=R,k<=j$为$a_i=0$的转移方式。

不如$f(i,j)$表示前i个数中以$<=j$的结尾的答案，一来是这样表示是一个单调序列，二来转移简洁了些：$f(i,j)=f(i-1,j)$，$f(i,a_i~R)>?=f(i-1,a_i-1),j<a_i$，$f(i,j)=f(i-1,j-1)+1,L<=j<=R$，诸如此类，细节略。

这些操作，在从i-1变成i时可以用一个平衡树维护。需要区间加，区间赋值，单点查询。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<stdlib.h>
#include<math.h>
//#include<time.h>
//#include<iostream>
using namespace std;

int n,L,R,m=100001;
#define maxn 100011
int a[maxn];

inline int max(int x,int y) {return x>y?x:y;}
inline int min(int x,int y) {return x<y?x:y;}
struct Splay
{
    struct Node
    {
        int v,size,Max,Min;
        int add,be;
        int fa,son[2];
    }a[maxn<<1];
    int size,root,live,die;
    Splay() {size=root=0;}
    inline void besingle(int x,int v)
    {
        if (!x) return;
        a[x].v=v; a[x].Max=a[x].Min=v;
        a[x].add=0;
        a[x].be=v;
    }
    inline void addsingle(int x,int v)
    {
        if (!x) return;
        a[x].v+=v; a[x].Max+=v; a[x].Min+=v;
        if (a[x].be) a[x].be+=v;
        else a[x].add+=v;
    }
    inline void down(int x)
    {
        const int &p=a[x].son[0],&q=a[x].son[1];
        if (a[x].add) addsingle(p,a[x].add),addsingle(q,a[x].add),a[x].add=0;
        if (a[x].be) besingle(p,a[x].be),besingle(q,a[x].be),a[x].be=0;
    }
    inline void up(int x)
    {
        if (!x || x==live || x==die) return;
        const int &p=a[x].son[0],&q=a[x].son[1];
        a[x].size=a[p].size+a[q].size+1;
        a[x].Max=max(a[p].Max,max(a[q].Max,a[x].v));
        a[x].Min=min(a[p].Min,min(a[q].Min,a[x].v));
    }
    int sta[maxn<<1],top;
    inline void download(int x)
    {
        top=0; for (int i=x;i;i=a[i].fa) sta[++top]=i;
        while (top) down(sta[top--]);
    }
    inline void rotate(int x)
    {
        const int y=a[x].fa,z=a[y].fa;
        bool w=(x==a[y].son[0]);
        a[x].fa=z;
        if (z) a[z].son[y==a[z].son[1]]=x;
        a[y].son[w^1]=a[x].son[w];
        if (a[x].son[w]) a[a[x].son[w]].fa=y;
        a[x].son[w]=y;
        a[y].fa=x;
        up(y); up(z);
    }
    inline void splay(int x,int top)
    {
        download(x);
        while (a[x].fa!=top)
        {
            const int y=a[x].fa,z=a[y].fa;
            if (z!=top)
            {
                if ((x==a[y].son[0])^(y==a[z].son[0])) rotate(x);
                else rotate(y);
            }
            rotate(x);
        }
        up(x);
        if (!top) root=x;
    }
    inline void build(int &x,int L,int R)
    {
        if (L>R) {x=0;return;}
        x=++size;
        a[x].v=a[x].add=a[x].be=0;
        if (L==R)
        {
            a[x].son[0]=a[x].son[1]=0; a[x].size=1; a[x].Max=a[x].Min=0;
            if (L==0) live=x; if (L==m+1) die=x; return;
        }
        const int mid=(L+R)>>1;
        if (mid==0) live=x; if (mid==m+1) die=x;
        build(a[x].son[0],L,mid-1);
        if (a[x].son[0]) a[a[x].son[0]].fa=x;
        build(a[x].son[1],mid+1,R);
        if (a[x].son[1]) a[a[x].son[1]].fa=x;
        up(x);
    }
    inline void build()
    {
        a[root].fa=0; build(root,0,m+1); 
        a[live].Max=a[die].Max=-0x3f3f3f3f;
        a[live].Min=a[die].Min=0x3f3f3f3f;
    }
    int find(int v)
    {
        int x=root,ans=0;
        while (x)
        {
            if (a[a[x].son[0]].size<v) ans=x,v-=a[x].size-a[a[x].son[1]].size,x=a[x].son[1];
            else x=a[x].son[0];
        }
        if (ans) splay(ans,0);
        return ans;
    }
    int getv(int id) {return a[find(id)].v;}
    inline void join(int x,int y)
    {
        a[x].fa=a[y].fa=0;
        if (x*y==0) {root=x+y; return;}
        int z=x;
        while (a[z].son[1]) z=a[z].son[1];
        splay(z,0);
        a[z].son[1]=y; a[y].fa=z; up(z);
    }
    inline void Delete(int id)
    {
        int x=find(id);
        join(a[x].son[0],a[x].son[1]);
    }
    inline void copy(int id)
    {
        int x=find(id),y=a[x].son[1];
        while (a[y].son[0]) y=a[y].son[0];
        splay(y,x);
        int z=++size;
        a[z].son[0]=a[z].son[1]=0; a[z].v=a[x].Max=a[x].Min=a[x].v; a[z].size=1; a[z].add=a[z].be=0;
        a[z].fa=y; a[y].son[0]=z; up(y); up(x);
    }
    inline int add(int L,int R,int v)
    {
        L--; R++;
        int y=find(R),x=find(L);
        splay(y,x); int z=a[y].son[0];
        addsingle(z,v);
        up(y); up(x);
        return a[z].Max;
    }
    inline void modmax(int L,int R,int v)
    {
        L--; R++;
        int y=find(R),x=find(L);
        splay(y,x); int z=a[y].son[0];
        while (1)
        {
            down(z);
            if (a[z].Min>=v) break;
            if (a[z].Max<=v) {besingle(z,v); break;}
            a[z].v=max(a[z].v,v);
            if (!a[z].son[0] && !a[z].son[1]) break;
            if (!a[z].son[0] || !a[z].son[1]) z=a[z].son[0]+a[z].son[1];
            else if (a[a[z].son[0]].Max<=v) besingle(a[z].son[0],v),z=a[z].son[1];
            else z=a[z].son[0];
        }
        while (z) {up(z); z=a[z].fa;}
    }
    int ans;
    inline void dfs(int x)
    {
        ans=max(ans,a[x].v);
        down(x);
        if (a[x].son[0]) dfs(a[x].son[0]);
        if (a[x].son[1]) dfs(a[x].son[1]);
    }
    int getans()
    {
        ans=0;
        dfs(root);
        return ans;
    }
}t;

int qread()
{
    char c;int s=0; while (!((c=getchar())>='0' && c<='9'));
    do s=s*10+c-'0'; while ((c=getchar())>='0' && c<='9'); return s;
}
int main()
{
//    freopen("orzzsn.in","r",stdin);
//    freopen("orzzsn.out","w",stdout);
    scanf("%d%d%d",&n,&L,&R);
    for (int i=1;i<=n;i++) a[i]=qread();
    
    t.build();
    for (int i=1;i<=n;i++)
    {
        if (a[i]) t.modmax(a[i]+1,m+1,t.getv(a[i])+1);
        else
        {
            t.Delete(R+1);
            t.copy(L);
            t.modmax(R+2,m+1,t.add(L+1,R+1,1));
        }
    }
    printf("%d
",t.getans());
    return 0;
}

然而不用这样。 维护这个序列的差分即可。假如当前要更新$[L,R]$，那就在L这里插入一个+1标记，在R右边删掉最左的一个差分标记即可，就包含了区间加和区间取Max的操作。