洛谷P6812

最新推荐文章于 2025-12-28 16:25:57 发布

原创最新推荐文章于 2025-12-28 16:25:57 发布 · 120 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #算法

数据结构专栏收录该内容

21 篇文章

订阅专栏

博客探讨了洛谷P6812问题，涉及先辈序列的性质，即非递减序列。作者提出使用线段树来解决区间查询与修改的问题。首先尝试了区间修改后单点查询的方法，但发现其复杂度为O(mnlogn)。接着，优化方案是在线段树节点上标记flag，通过比较子区间最左和最右值来判断是否为先辈。最后，文章提到了利用差分数组转换问题，通过查询区间内最小值来确定序列是否满足非递减条件，但该方法存在错误，需要进一步研究。

若该序列是先辈，假设取长度为k的后缀，则该序列中前k个元素都比其长度为k的后缀屑，因此不难得出先辈一定是一个非递减序列。因此题目的询问变成求一个序列是否为非递减序列，用线段树维护。
我的第一个想法，就是区间修改，然后根据要查询的区间对线段树中每个点单点查询，之后再判断是否是非递减序列。
代码如下：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1e6+10;
typedef long long LL;
int n,m,w[N];
struct node
{
    int l,r;
    LL v;
    LL add;
}tr[4*N];
void pushup(int u)
{
    tr[u].v=tr[u<<1].v+tr[u<<1|1].v;
}
void build(int u,int l,int r)
{
    if(l==r)
    {
        tr[u]={l,r,w[l],0};
        return;
    }
    tr[u]={l,r};
    int mid=l+r>>1;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
    pushup(u);
}
void pushdown(int u)
{
    if(tr[u].add)
    {
        tr[u<<1].add+=tr[u].add;
        tr[u<<1|1].add+=tr[u].add;
        tr[u<<1].v+=(tr[u<<1].r-tr[u<<1].l+1)*tr[u].add;
        tr[u<<1|1].v+=(tr[u<<1|1].r-tr[u<<1|1].l+1)*tr[u].add;
        tr[u].add=0;
    }
}
void modify(int u,int l,int r,int c)
{
    if(tr[u].l>=l&&tr[u].r<=r)
    {
        tr[u].add+=c;
        tr[u].v+=(tr[u].r-tr[u].l+1)*c;
        return;
    }
    pushdown(u);
    int mid=tr[u].l+tr[u].r>>1;
    if(l<=mid) modify(u<<1,l,r,c);
    if(r>mid) modify(u<<1|1,l,r,c);
    pushup(u);
}
LL query(int u,int x)
{
    if(tr[u].l==x&&tr[u].r==x) return (LL)tr[u].v;
    pushdown(u);
    int mid=tr[u].l+tr[u].r>>1;
    if(x<=mid) return query(u<<1,x);
    else return query(u<<1|1,x);
}
int main()
{
    scanf("%d%d", &n, &m);
    for(int i=1;i<=n;i++) scanf("%d",&w[i]);
    build(1,1,n);
    while(m--)
    {
        int op,l,r,c;
        scanf("%d",&op);
        if(op==2)
        {
            scanf("%d%d", &l, &r);
            bool flag=true;
            for(int i=l;i<r;i++)
                if(query(1,i)>query(1,i+1))
                {
                    flag=false;
                    break;
                }
            if(flag) printf("Yes\n");
            else printf("No\n");
        }
        else
        {
            scanf("%d%d%d",&l,&r,&c);
            modify(1,l,r,c);
            // for(int i=1;i<=n;i++)
            //     cout<<query(1,i)<<' ';
            // cout<<endl;
        }
    }
    return 0;
}

然而复杂度为O(mnlogn)，铁t。

下面来看第二种做法：
我们对线段树中每个结点打上一个flag标记，用于标记当前区间是否为先辈，再用lv和rv分别表示当前区间最左边点的值和最右边点的值。因此，维护一个点u所在区间是否为先辈时，只需判断三个条件，全满足即为先辈：①u<<1所在区间为先辈 ②u<<1|1所在区间也为先辈 ③都为先辈时，u<<1和u<<1|1区间内已经非递减了，如果u为先辈一定有u<<1最右边的点 <= u<<1|1最左边的点，由此结束。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1e6+10;
typedef long long LL;
int n,m;
LL w[N];
struct node
{
    int l,r;
    LL lv,rv;//区间左右边界点的值
    bool flag;
    LL lazy;
}tr[4*N];
void update(int u,LL k)
{
    tr[u].lv+=k;tr[u].rv+=k;tr[u].lazy+=k;
}
void pushup(node &u,const node &a,const node &b)
{
    u.lv=a.lv;u.rv=b.rv;
    //u为先辈当且仅当u<<1、u<<1|1都为先辈，且u<<1的右边界<=u<<1|1的左边界【即保证合并后也单调递增】
    u.flag=a.flag&&b.flag&&(a.rv<=b.lv);
}
void pushdown(int u)
{
    if(tr[u].lazy)
    {
        update(u<<1,tr[u].lazy);
        update(u<<1|1,tr[u].lazy);
        tr[u].lazy=0;
    }
}
void build(int u,int l,int r)
{
    if(l==r)
    {
        tr[u]={l,r,w[l],w[l],true};//叶结点一定是先辈
        return;
    }
    tr[u]={l,r};
    int mid=l+r>>1;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
    pushup(tr[u],tr[u<<1],tr[u<<1|1]);
}
void modify(int u,int l,int r,LL c)
{
    if(tr[u].l>=l&&tr[u].r<=r)
    {
        tr[u].lv+=c;tr[u].rv+=c;tr[u].lazy+=c;
        return;
    }
    pushdown(u);
    int mid=tr[u].l+tr[u].r>>1;
    if(l<=mid) modify(u<<1,l,r,c);
    if(r>mid) modify(u<<1|1,l,r,c);
    pushup(tr[u],tr[u<<1],tr[u<<1|1]);
}
node query(int u,int l,int r)
{
    if(tr[u].l>=l&&tr[u].r<=r) return tr[u];
    pushdown(u);
    int mid=tr[u].l+tr[u].r>>1;
    if(r<=mid) return query(u<<1,l,r);
    if(l>mid) return query(u<<1|1,l,r);
    node res;
    pushup(res,query(u<<1,l,r),query(u<<1|1,l,r));
    return res;
}
int main()
{
    scanf("%d%d", &n, &m);
    for(int i=1;i<=n;i++) scanf("%lld",&w[i]);
    build(1,1,n);
    while(m--)
    {
        int op,l,r;
        LL c;
        scanf("%d",&op);
        if(op==2)
        {
            scanf("%d%d", &l, &r);
            printf("%s\n",query(1,l,r).flag?"Yes":"No");
        }
        else
        {
            scanf("%d%d%lld",&l,&r,&c);
            modify(1,l,r,c);
            // for(int i=1;i<=n;i++)
            //     cout<<query(1,i)<<' ';
            // cout<<endl;
        }
    }
    
    return 0;
}

还有一种非常巧妙的办法，将每两个相邻元素的差（即差分数组w[i+1]-w[i]）作为线段树中的元素，如果该元素>=0，则说明w[i]>w[i+1]，即非递减；由此，差分数组的存在将区间修改转化为两个单点修改，而区间查询判断时，若所有元素都满足这个条件，则这个序列是先辈。但我们总不能一个一个判断吧，否则和第一种做法没区别了。因此在这里，我们可以求区间内的最小值，如果它都>=0，则该序列一定满足非递减，因此序列也就是先辈了。【但是不知道这里为什么一直RE，先记录这个思路，啥时候看出来了再改吧。】
代码如下：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1e6+10;
typedef long long LL;
struct node
{
    int l,r;
    LL minn;
}tr[4*N];
int a[N],n,m;
void pushup(int u)
{
    tr[u].minn=min(tr[u<<1].minn,tr[u<<1|1].minn);
}
void build(int u,int l,int r)
{
    if(l==r)
    {
        tr[u]={l,r,a[l]-a[l-1]};
        return;
    }
    tr[u]={l,r};
    int mid=l+r>>1;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
    pushup(u);
}
void modify(int u,int x,LL c)
{
    if(tr[u].l==x&&tr[u].r==x)
    {
        tr[u].minn+=c;
        return;
    }
    int mid=tr[u].l+tr[u].r>>1;
    if(x<=mid) modify(u<<1,x,c);
    else modify(u<<1|1,x,c);
    pushup(u);
}
LL query(int u,int l,int r)
{
    if(tr[u].l>=l&&tr[u].r<=r) return tr[u].minn;
    int mid=tr[u].l+tr[u].r>>1;
    LL res=1e19;
    if(l<=mid) res=min(res,query(u<<1,l,r));
    if(r>mid) res=min(res,query(u<<1|1,l,r));
    return res;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>a[i];
    build(1,1,n);
    while (m -- )
    {
        int opt,l,r,v;
        cin>>opt;
        if(opt==1)
        {
            cin>>l>>r>>v;
            //实现[l,r]中+v
            modify(1,l,v);
            modify(1,r+1,-v);
        }
        else
        {
            cin>>l>>r;
            if(query(1,l+1,r)>=0) cout<<"Yes"<<endl;
            else cout<<"No"<<endl;
        }
    }
    return 0;
}