【线段树模板以及Codeforces线段树专题总结】

最新推荐文章于 2022-07-27 22:41:27 发布
置顶 最新推荐文章于 2022-07-27 22:41:27 发布
阅读量3.8k 收藏 45
点赞数 25
分类专栏： 个人训练计划 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_38891827/article/details/89139958
版权
本文详细介绍线段树数据结构的原理与应用，包括线段树的构建、更新、查询等核心操作，以及在多种典型问题中的实战案例，如区间更新、区间查询、树状数组与线段树结合等，旨在帮助读者掌握线段树解决复杂区间问题的能力。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

线段树模板

//线段树一般用来解决可合并的区间问题
//树上维护子树区间的问题也可以通过dfs序+线段树去维护
//不要质疑线段树写法的正确性，首先检查做法是否正确
//不要忘记build，dfs序问题build时注意下标
//数组记得开4倍，push_down一定要想好顺序
//对于每个问题，我们只要考虑清楚push_down和push_up的写法即可
//当问题不好处理的时候，想象一下对于单次询问暴力的做法，再去想区间合并操作
//对于求一个区间内权值大于y的最小下标x时，就先看左区间是不是能找到这样的值，找不到再找右区间
//若找不到返回-1否则返回下标，用区间max<=y进行剪枝防止复杂度退化
//TLE有可能是数据溢出的问题，检查函数传参的变量类型(是否需要long long)
//TLE不要怀疑线段树的复杂度，要想想有没有优化或者哪里是不是死循环
//多个update或者query检查是否调用错误
//如果区间赋值对子区间的改变有多次的影响，要把add数组更改带来的变化存在另一个lazy数组
struct T
{
    int l,r,mid;
    int add,sum;
}tree[maxn<<2];
void push_up(int rt)
{
    //在这里合并子区间
}
void push_down(int rt)
{
    if(tree[rt].add)
    {
    	//在这里下传标记
        tree[rt].add=0;
    }
}
void build(int rt,int l,int r)
{
    tree[rt].add=0;
    tree[rt].l=l;
    tree[rt].r=r;
    if(l==r)
    {
        tree[rt].sum=a[l];
        return ;
    }
    int mid=tree[rt].mid=l+r>>1;
    build(rt<<1,l,mid);
    build(rt<<1|1,mid+1,r);
    push_up(rt);
}
void update(int rt,int l,int r)
{
    if(tree[rt].r<l||tree[rt].l>r) return ;
    if(tree[rt].l>=l&&tree[rt].r<=r)
    {
        //更新区间答案，并更新lazy数组
        return ;
    }
    push_down(rt);
    if(tree[rt].mid>=l) update(rt<<1,l,r);
    if(tree[rt].mid<r) update(rt<<1|1,l,r);
    push_up(rt);
}
int query(int rt,int l,int r)
{
    if(tree[rt].r<l||tree[rt].l>r) return 0;
    if(tree[rt].l>=l&&tree[rt].r<=r) // 返回本区间答案。
    push_down(rt);
    int ans=0;
    if(tree[rt].mid>=l) ans+=query(rt<<1,l,r);
    if(tree[rt].mid<r) ans+=query(rt<<1|1,l,r);
    push_up(rt);
    return ans;
}

线段树第一题

链接：

Codeforces Round #442 (Div. 2)E. Danil and a Part-time Job

题意：

给你一颗有根树，树上每一个节点有一个灯，现在要支持两种操作，第一种操作是统计一颗子树内开着的灯个数。第二种操作是将一个子树内的所有灯状态改变(开灯->关灯，关灯->开灯)。

做法：

首先对于树的dfs序建立线段树，这样每一棵子树都能表示成一段区间，之后问题就转换为，区间改变01状态，区间求和。
这个问题我们可以通过lazy数组实现，首先我们统计出最初状态下每棵子树内灯的状况，将每棵子树内亮着的灯的个数表示为 s u m sum sum,对于区间更新，我们只需要用一个 a d d add add表示这个区间是否被翻转， a d d add add每次和 1 1 1进行异或，这表示如果偶数次翻转，区间就会回到最初的情况，之后我们只需要知道这个区间是否被翻转也就可以更新 s u m sum sum。

对于 p u s h _ d o w n push \_ down push_down函数，我们首先要更新子区间的 a d d add add数组 ( 0 − &gt; 1 , 1 − &gt; 0 ) (0-&gt;1,1-&gt;0) (0−>1,1−>0)，之后更新子区间的 s u m sum sum，这里我们要知道子区间内一共点的个数，也就是 ( r − l + 1 ) (r-l+1) (r−l+1)，之后再更新 s u m sum sum即可。

对于 p u s h _ u p push\_up push_up函数，只需要合并子区间的和即可。

代码

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
const int maxn = 2e5+5;
int tim;
int t[maxn];
int sum[maxn],sum2[maxn];
int in[maxn],ou[maxn],dfn[maxn];
vector<int> G[maxn];
void dfs(int rt,int fa)
{
    in[rt]=++tim;
    dfn[tim]=rt;
    for(int i=0;i<G[rt].size();i++)
    {
        int to=G[rt][i];
        if(to==fa) continue;
        dfs(to,rt);
    }
    ou[rt]=tim;
}
struct T
{
    int l,r,mid;
    int add,sum;
}tree[maxn<<2];
void push_up(int rt)
{
    tree[rt].sum=tree[rt<<1].sum+tree[rt<<1|1].sum;
}
void push_down(int rt)
{
    if(tree[rt].add)
    {
        tree[rt<<1].add^=1;
        tree[rt<<1].sum=(tree[rt<<1].r-tree[rt<<1].l+1)-tree[rt<<1].sum;
        tree[rt<<1|1].add^=1;
        tree[rt<<1|1].sum=(tree[rt<<1|1].r-tree[rt<<1|1].l+1)-tree[rt<<1|1].sum;
        tree[rt].add=0;
    }
}
void build(int rt,int l,int r)
{
    tree[rt].add=0;
    tree[rt].l=l;
    tree[rt].r=r;
    if(l==r)
    {
        tree[rt].sum=t[dfn[l]];//dfs序的问题这里记得dfn
        return ;
    }
    int mid=tree[rt].mid=l+r>>1;
    build(rt<<1,l,mid);
    build(rt<<1|1,mid+1,r);
    push_up(rt);
}
void update(int rt,int l,int r)
{
    if(tree[rt].r<l||tree[rt].l>r) return ;
    if(tree[rt].l>=l&&tree[rt].r<=r)
    {
        tree[rt].sum=(tree[rt].r-tree[rt].l+1)-tree[rt].sum;
        tree[rt].add^=1;
        return ;
    }
    push_down(rt);
    if(tree[rt].mid>=l) update(rt<<1,l,r);
    if(tree[rt].mid<r) update(rt<<1|1,l,r);
    push_up(rt);
}
int query(int rt,int l,int r)
{
    if(tree[rt].r<l||tree[rt].l>r) return 0;
    if(tree[rt].l>=l&&tree[rt].r<=r) return tree[rt].sum;
    push_down(rt);
    int ans=0;
    if(tree[rt].mid>=l) ans+=query(rt<<1,l,r);
    if(tree[rt].mid<r) ans+=query(rt<<1|1,l,r);
    push_up(rt);
    return ans;
}
int main()
{
    int n,x;
    scanf("%d",&n);
    for(int i=2;i<=n;i++)
    {
        scanf("%d",&x);
        G[x].push_back(i);
        G[i].push_back(x);
    }
    for(int i=1;i<=n;i++) scanf("%d",&t[i]);
    dfs(1,-1);//获取dfs序
    build(1,1,n);
    int q;
    scanf("%d",&q);
    while(q--)
    {
        char op[4];
        int v;
        scanf("%s%d",op,&v);
        if(op[0]=='p') update(1,in[v],ou[v]);
        else printf("%d\n",query(1,in[v],ou[v]));
    }
    return 0;
}

线段树第二题

链接

Codecraft-18 and Codeforces Round #458 (Div. 1 + Div. 2, combined)

题意

给你一个区间，要支持两种区间操作。
第一种操作是单点更新，第二种操作是询问某个区间是否可以去掉一个元素使这段区间的 g c d gcd gcd为 x x x的倍数。

做法

首先先要支持区间 g c d gcd gcd和单点更新，这个用普通的线段树就可以维护。
之后对于每个操作 2 2 2,我们先查询当前区间的 g c d gcd gcd是否为 x x x的倍数，若当前 g c d gcd gcd为 x x x的倍数，则随意去掉哪个元素即可。
否则查询左右区间的 g c d gcd gcd，如果两个子区间的 g c d gcd gcd都不是 x x x的倍数，则至少删除两个元素，所以直接返回 f a l s e false false。
如果其中一个是 x x x的倍数，则问题转换为一个子问题，只需要查询另一个子区间去掉一个元素 g c d gcd gcd能否是 x x x的倍数即可。

代码

#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 5e5+5;
int a[maxn];
struct T
{
    int l,r,mid;
    int GCD;
}tree[maxn<<2];
void push_up(int rt)
{
    tree[rt].GCD=__gcd(tree[rt<<1].GCD,tree[rt<<1|1].GCD);
}
void build(int rt,int l,int r)
{
    tree[rt].l=l;
    tree[rt].r=r;
    if(l==r)
    {
        tree[rt].GCD=a[l];
        return ;
    }
    int mid=tree[rt].mid=l+r>>1;
    build(rt<<1,l,mid);
    build(rt<<1|1,mid+1,r);
    push_up(rt);
}
void update(int rt,int pos,int val)
{
    if(tree[rt].l==tree[rt].r)
    {
        tree[rt].GCD=val;
        return ;
    }
    if(pos<=tree[rt].mid) update(rt<<1,pos,val);
    else update(rt<<1|1,pos,val);
    push_up(rt);
}
int query(int rt,int l,int r)
{
    if(tree[rt].r<l||tree[rt].l>r) return 0;
    if(tree[rt].l>=l&&tree[rt].r<=r)
    {
        return tree[rt].GCD;
    }
    int ans=0;
    if(tree[rt].mid>=l) ans=__gcd(ans,query(rt<<1,l,r));
    if(tree[rt].mid<r) ans=__gcd(ans,query(rt<<1|1,l,r));
    return ans;
}
int findpos(int rt,int l,int r,int x)
{
    if(l==r) return 1;//查询到长度为1的区间，说明操作合法
    int ansl=x,ansr=x;
    if(tree[rt].mid>=l) ansl=query(rt<<1,l,tree[rt].mid);
    if(tree[rt].mid<r) ansr=query(rt<<1|1,tree[rt].mid+1,r);
    ansl=__gcd(ansl,x);
    ansr=__gcd(ansr,x);
    if(ansl!=x&&ansr!=x) return -1;//两个子区间的gcd都不是x的倍数，一定不合法
    else if(ansl==x&&ansr==x) return 1;//两个子区间的gcd都是x的倍数，一定合法
    else if(ansl==x) return findpos(rt<<1|1,tree[rt].mid+1,r,x);//转换为子问题求解
    else return findpos(rt<<1,l,tree[rt].mid,x);
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    build(1,1,n);
    int q;
    scanf("%d",&q);
    while(q--)
    {
        int op,l,r,x;
        scanf("%d",&op);
        if(op==1)
        {
            scanf("%d%d%d",&l,&r,&x);
            if(findpos(1,l,r,x)==1) puts("YES");
            else puts("NO");
        }
        else
        {
            scanf("%d%d",&l,&x);
            update(1,l,x);
        }
    }
    return 0;
}

线段树第三题

链接：

Codeforces Round #111 (Div. 2) E. Buses and People

题意

有n个公交车，每个公交车的信息有 s i s_i si​(公交车起始下标)， f i f_i fi​（公交车终点下标）, t i t_i ti​(公交车发车时间)。
有m个乘客，每个乘客的信息有 l i l_i li​(乘客起始下标)， r i r_i ri​(乘客下车的下标)， b i b_i bi​(乘客上车时间)。
乘客 i i i坐上公交车 j j j的前提是 s j ≤ l i s_j \leq l_i sj​≤li​, r i ≤ f j r_i \leq f_j ri​≤fj​, b i ≤ t j b_i \leq t_j bi​≤tj​,问每一个乘客能坐的公交车中发车时间最小的公交车编号。

做法

首先先将所有公交车和乘客放到一起，之后按照起始下标排序，这样就能保证每个人乘客之前的公交车一定满足 s j ≤ l i s_j \leq l_i sj​≤li​。

之后我们对时间进行离散化建立线段树,每个节点存储当前t能到达的最大的 f f f，对于每个乘客，我们只需要查找小于等于 t i t_i ti​的时间区间中最小的满足 r i ≤ f j r_i \leq f_j ri​≤fj​的t即可。

所以问题就转换为给定一个区间，求区间内最小的下标满足权值大于某个给定值。这个问题只需要在线段树上优先查询左子区间是否有满足情况的点，向下递归询问即可，注意要用区间max进行剪枝。

代码


#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 2e5+5;
struct T
{
    int l,r,mid;
    int val,id;
}tree[maxn<<2];
void push_up(int rt)
{
    tree[rt].val=max(tree[rt<<1].val,tree[rt<<1|1].val);
}
void build(int rt ,int l,int r)
{
    tree[rt].l=l;
    tree[rt].r=r;
    if(l==r)
    {
        tree[rt].id=-1;
        tree[rt].val=0;
        return ;
    }
    int mid=tree[rt].mid=l+r>>1;
    build(rt<<1,l,mid);
    build(rt<<1|1,mid+1,r);
    push_up(rt);
}
void update(int rt,int pos,int val,int id)
{
    if(tree[rt].l==tree[rt].r)
    {
        tree[rt].val=max(tree[rt].val,val);
        tree[rt].id=id;
        return ;
    }
    if(pos<=tree[rt].mid) update(rt<<1,pos,val,id);
    else update(rt<<1|1,pos,val,id);
    push_up(rt);
}
int query(int rt,int val,int l,int r)
{
    if(tree[rt].l>=l&&tree[rt].r<=r)
    {
        if(tree[rt].val<val) return -1;
    }
    if(tree[rt].l==tree[rt].r) return tree[rt].id;
    int ans=-1;
    if(tree[rt].mid>=l)
    {
        ans=query(rt<<1,val,l,r);
        if(ans!=-1) return ans;
    }
    if(tree[rt].id<r)
    {
        ans=query(rt<<1|1,val,l,r);
        if(ans!=-1) return ans;
    }
    return -1;
}
struct Bus
{
    int l,r,t,id;
    bool operator<(const Bus y)const
    {
        if(l==y.l) return id<y.id;//要注意一个l同时有公交车和乘客，先更新公交车信息。
        return l<y.l;
    }
}bus[maxn<<2];
int Hash[maxn<<2],cnt;
int ans[maxn<<2];
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n+m;i++)
    {
        scanf("%d%d%d",&bus[i].l,&bus[i].r,&bus[i].t);
        bus[i].id=i;
        Hash[++cnt]=bus[i].t;
    }
    sort(bus+1,bus+1+n+m);
    sort(Hash+1,Hash+1+cnt);
    build(1,1,cnt);
    int d=unique(Hash+1,Hash+1+cnt)-Hash-1;//对时间进行离散化
    for(int i=1;i<=n+m;i++)
    {
        int pos=lower_bound(Hash+1,Hash+1+d,bus[i].t)-Hash;
        if(bus[i].id<=n) update(1,pos,bus[i].r,bus[i].id);//公交车信息进行更新
        else ans[bus[i].id-n]=query(1,bus[i].r,pos,cnt);//乘客进行查询
    }
    for(int i=1;i<=m;i++) printf("%d ",ans[i]);
    return 0;
}

线段树第四题

链接:

Codeforces Beta Round #19 D. Points

题意

给你一个笛卡尔坐标系，现在要支持三种操作，第一种操作是添加一个点(x,y),第二种操作是删除一个点(x,y), 第三种操作是查询严格在点(x,y)右上角的点中，横坐标最小的点，如果有多个点，选择纵坐标最小的那个。

做法

首先题中给出的坐标范围都是1e9,所以需要对x轴进行离散化，建立线段树，每个节点存储区间内所有点中y的最大值，所以叶子节点存储的是当前x下y的最大值。 之后对于每个x开一个set存储横坐标为x的所有y。
之后对于操作1,2,我们只需要单点更新，并且在set中进行insert和erase。
对于操作3,我们首先转换为经典问题，求x+1到inf区间内最小的下标满足权值大于y，我们只要在线段树上优先看左子树是否有满足条件的点，转换为自问题递归求解即可,注意要用区间max进行剪枝，不然复杂度会退化。
这样我们就知道最小的存在大于y的下标x，之后在x所在的set中upper_bound查找第一个大于y的值即可。

代码

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<set>
using namespace std;
const int maxn = 2e5+5;
struct T
{
    int l,r,mid;
    int val,id;
}tree[maxn<<2];
multiset<int> s[maxn<<2];
void push_up(int rt)
{
    tree[rt].val=max(tree[rt<<1].val,tree[rt<<1|1].val);
}
void build(int rt,int l,int r)
{
    tree[rt].l=l;
    tree[rt].r=r;
    tree[rt].val=0;
    if(l==r)
    {
        s[l].insert(-1);
        tree[rt].val=-1;
        return ;
    }
    int mid=tree[rt].mid=l+r>>1;
    build(rt<<1,l,mid);
    build(rt<<1|1,mid+1,r);
    push_up(rt);
    return ;
}
void update(int rt,int pos,int val,int flag)
{
    if(tree[rt].l==tree[rt].r)//递归到叶子节点更新set
    {
        if(flag==0) s[tree[rt].l].erase(val);
        else s[tree[rt].l].insert(val);
        tree[rt].id=pos;
        tree[rt].val=*(s[tree[rt].l].rbegin());
        return ;
    }
    if(pos<=tree[rt].mid) update(rt<<1,pos,val,flag);
    else  update(rt<<1|1,pos,val,flag);
    push_up(rt);
    return ;
}
int query(int rt,int val,int l,int r)
{
    if(tree[rt].l>r||tree[rt].r<l) return -1;
    if(tree[rt].l>=l&&tree[rt].r<=r)//区间最大值进行剪枝
    {
        if(tree[rt].val<=val) return -1;
    }
    if(tree[rt].l==tree[rt].r) return tree[rt].id;
    if(tree[rt].mid>=l)//优先看左区间是否有满足情况的点
    {
        int res=query(rt<<1,val,l,r);
        if(res!=-1) return res;
    }
    if(tree[rt].mid<r)
    {
        int res=query(rt<<1|1,val,l,r);
        if(res!=-1) return res;
    }
    return -1;
}
struct data
{
    int flag,x,y;
}p[maxn];
char op[maxn];
int d;
int a[maxn];//原数组
int b[maxn];//每个位置离散后的值
int c[maxn];//表示离散后为i的原来的值为c[i]
int Hash[maxn];//hash去重数组
void GetHash(int a[],int n)
{
    for(int i=1;i<=n;i++) Hash[i]=a[i];
    sort(Hash+1,Hash+1+n);
    d=unique(Hash+1,Hash+1+n)-Hash-1;
    for(int i=1;i<=n;i++)
    {
        b[i]=lower_bound(Hash+1,Hash+1+d,a[i])-Hash;
        c[b[i]]=a[i];
    }
}
int main()
{
    int n,x,y;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%s%d%d",	op,&x,&y);
        if(op[0]=='a') p[i].flag=1;
        else if(op[0]=='r') p[i].flag=2;
        else p[i].flag=3;
        p[i].x=x;
        p[i].y=y;
        a[i]=x;
    }
    GetHash(a,n);//对x轴进行离散化
    build(1,1,d);//对x轴建立线段树
    for(int i=1;i<=n;i++)
    {
        if(p[i].flag==1) update(1,b[i],p[i].y,1);
        else if(p[i].flag==2) update(1,b[i],p[i].y,0);
        else
        {
            int res=query(1,p[i].y,b[i]+1,d);
            if(res==-1) printf("-1\n");
            else
            {
                set<int>::iterator it = s[res].upper_bound(p[i].y);
                printf("%d %d\n",c[res],(*it));
            }
        }
    }
    return 0;
}

线段树第五题

链接：

CodeForces-483D Interesting Array

题意

让你构造一个数列，满足m种限制条件，每种限制条件是l,r,x,要求构造的序列区间[l,r] 与运算的值结果为x。

做法

首先由一个拆位的做法，对于每次询问，拆成30位分别进行构造，对于每个为0的位，区间查询这一位下[l,r]的和是不是等于区间长度，也就是看区间[l,r]与的结果是否为0。对于每个为1的位，区间更新。但是这个做法是两个log的，楼主并有没卡过去。
之后楼主的做法是这样的，首先对于每个查询，我们可以看当前[l,r]区间与的结果，如果这个结果是x的子集（这里的子集是二进制下的01序列），那么说明我们可以通过区间或运算让区间[l,r]的结果变成x，否则一定不行会破坏之前的关系，于是只需要线段树维护区间与运算，区间更新或运算即可。(要注意同一个区间多次询问的情况特判一下)。

代码

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<map>
using namespace std;
typedef pair<int,int> pii;
const int maxn = 1e5+5;
struct T
{
    int l,r,mid;
    int sum,add;
}tree[maxn<<2];
void push_up(int rt)
{
    tree[rt].sum=tree[rt<<1].sum&tree[rt<<1|1].sum;
}
void push_down(int rt)
{
    if(tree[rt].add!=0)
    {
        int tmp=tree[rt].add;
        tree[rt<<1].add=tree[rt<<1].add|tmp;
        tree[rt<<1].sum=tree[rt<<1].sum|tmp;
        tree[rt<<1|1].add=tree[rt<<1|1].add|tmp;
        tree[rt<<1|1].sum=tree[rt<<1|1].sum|tmp;
        tree[rt].add=0;
    }
}
void build(int rt,int l,int r)
{
    tree[rt].l=l;
    tree[rt].r=r;
    tree[rt].sum=0;
    tree[rt].add=0;
    if(l==r) return ;
    int mid=tree[rt].mid=l+r>>1;
    build(rt<<1,l,mid);
    build(rt<<1|1,mid+1,r);
    return ;
}
void update(int rt,int l,int r,int val)
{
    if(tree[rt].l>r||tree[rt].r<l) return ;
    if(tree[rt].sum==tree[rt].r-tree[rt].l+1) return ;
    if(tree[rt].l>=l&&tree[rt].r<=r)
    {
        tree[rt].sum=tree[rt].sum|val;
        tree[rt].add=tree[rt].add|val;
        return ;
    }
    push_down(rt);
    if(tree[rt].mid>=l) update(rt<<1,l,r,val);
    if(tree[rt].mid<r) update(rt<<1|1,l,r,val);
    push_up(rt);
    return ;
}
int query(int rt,int l,int r)
{
    if(tree[rt].l>r||tree[rt].r<l) return 0;
    if(tree[rt].l>=l&&tree[rt].r<=r) return tree[rt].sum;
    push_down(rt);
    int ans=(1<<30)-1;
    if(tree[rt].mid>=l) ans=ans&query(rt<<1,l,r);
    if(tree[rt].mid<r) ans=ans&query(rt<<1|1,l,r);
    push_up(rt);
    return ans;
}
int ans[maxn];
map<pii,int> mp;
int main()
{
    int n,m,l,r,q;
    scanf("%d%d",&n,&m);
    build(1,1,n);
    int flag=0;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&l,&r,&q);
        if(mp.count(pii(l,r)))
        {
            if(mp[pii(l,r)]!=q) flag=1;
        }
        mp[pii(l,r)]=q;
        if(flag==1) continue;
        int res=query(1,l,r);
        if((q&res)==res)
        {
            int tmp=q-res;
            update(1,l,r,tmp);
        }
        else flag=1;
    }
    if(flag==1) return 0*puts("NO");
    for(int i=1;i<=n;i++) ans[i]=query(1,i,i);
    puts("YES");
    for(int i=1;i<=n;i++) printf("%d ",ans[i]);
    return 0;
}

线段树第六题

链接：

Educational Codeforces Round 52 C. Make It Equal

题意：

给你一些从左到右摆放的n堆正方体，每堆正方体由一些正方体堆叠而成，现在每次可以沿着某个高度砍一刀，这个高度之上的正方体都会被砍掉，要求是掉落的正方体个数不超过k，问最少砍多少刀能让所有正方体高度相同。

做法：

首先可以桶排序，高度从高到低统计出每种高度正方体高度的个数，之后从高到低贪心的看是不是能砍即可。时间复杂度 O ( n log ⁡ n ) O(n \log n) O(nlogn)
但是楼主拉线段树专题不小心看到了这道题，于是给出线段树的做法。首先依旧是统计出每种高度的正方体的个数，之后我们统计前缀和，之后问题就转换为区间[1,200000]内查找小于k的最大值，找到之后区间更新即可。时间复杂度 O ( n log ⁡ n ) O(n \log n) O(nlogn)，但是这个做法不太优雅，要注意很多细节。
两个做法都要注意不需要砍的情况。

代码：

做法一：
#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn = 4e5+5;
ll a[maxn],b[maxn],sum[maxn];
int main()
{
    int n,k;
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    sort(a+1,a+1+n);
    if(a[1]==a[n])
    {
        puts("0");
        return 0;
    }
    int pos=1;
    for(int i=1;i<=n;i++)
    {
        while(pos<=200000&&pos<=a[i])
        {
            sum[pos]=(n-i+1);
            pos++;
        }
    }
    for(int i=1;i<=200000;i++) b[i]=sum[200000-i+1];
    pos=1;
    ll cnt=0;
    int ans=0;
    while(pos<=200000)
    {
        if(cnt+b[pos]<=k)
        {
            cnt+=b[pos];
            pos++;
            if(pos==200001) ans++;
        }
        else
        {
            ans++;
            if(b[pos]==n) break;
            cnt=b[pos];
            pos++;
        }
    }
    printf("%d\n",ans);
    return 0;
}
做法二：
#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pll;
const int maxn = 4e5+5;
struct T
{
    int l,r,mid;
    ll add,val;
}tree[maxn<<2];
ll a[maxn];
ll sum[maxn];
ll b[maxn];
void up(int rt)
{
    tree[rt].val=min(tree[rt<<1].val,tree[rt<<1|1].val);
    return;
}
void down(int rt)
{
    if(tree[rt].add!=0)
    {
        ll tmp=tree[rt].add;
        tree[rt<<1].val+=tmp;
        tree[rt<<1|1].val+=tmp;
        tree[rt<<1].add+=tmp;
        tree[rt<<1|1].add+=tmp;
        tree[rt].add=0;
    }
}
void build(int rt,int l,int r)
{
    tree[rt].l=l;
    tree[rt].r=r;
    tree[rt].add=0;
    if(l==r)
    {
        tree[rt].val=b[l];
        return ;
    }
    int mid=tree[rt].mid=l+r>>1;
    build(rt<<1,l,mid);
    build(rt<<1|1,mid+1,r);
    up(rt);
}
pll query(int rt,int l,int r,ll val)
{
    if(tree[rt].val>val) return pll(-1,-1);
    if(tree[rt].l==tree[rt].r) return pll(tree[rt].l,tree[rt].val);
    down(rt);
    if(tree[rt<<1|1].val<=val) return query(rt<<1|1,l,r,val);
    else return query(rt<<1,l,r,val);
}
int main()
{
    int n,k;
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    sort(a+1,a+1+n);
    if(a[1]==a[n])
    {
        puts("0");
        return 0;
    }
    int pos=1;
    for(int i=1;i<=n;i++)
    {
        while(pos<=200000&&pos<=a[i])
        {
            sum[pos]=(n-i+1);
            pos++;
        }
    }
    for(int i=1;i<=200000;i++) b[i]=sum[200000-i+1];
    for(int i=1;i<=200000;i++) b[i]=b[i-1]+b[i];
    build(1,1,200000);
    pll tt=pll(0,0);
    int ans=0;
    ll cc=0;
    while(true)
    {
        tt=query(1,1,200000,k);
        ans++;
        tree[1].val-=tt.second;
        tree[1].add-=tt.second;
        if(tt.first==200000) break;
        cc+=tt.second;
        ll tm=b[tt.first+1]-cc;
        if(tm==n) break;
    }
    printf("%d\n",ans);
    return 0;
}

线段树第七题

链接：

http://codeforces.com/problemset/problem/296/C

题意：

给你n个数，有m次操作，每次操作为区间加，现在有k次大操作，每次大操作执行m个操作的[l,r]区间,问k次大操作之后这n个数变成什么样？

做法：

第一种做法就是先对k次大操作进行差分，就知道每个小操作执行次数，之后线段树维护区间加即可。
第二种做法就是知道每个小操作执行次数之后，在原数组上再差分一次，就可以得到每个数加多少值， O ( n ) O(n) O(n)即可完成。

代码：

做法一：
#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn = 2e5+5;
struct T
{
    int l,r,mid;
    ll val,add;
}tree[maxn<<2];
int a[maxn];
void up(int rt)
{
    tree[rt].val=tree[rt<<1].val+tree[rt<<1|1].val;
}
void down(int rt)
{
    if(tree[rt].add)
    {
        ll tmp=tree[rt].add;
        tree[rt<<1].add+=tmp;
        tree[rt<<1].val+=1LL*(tree[rt<<1].r-tree[rt<<1].l+1)*tmp;
        tree[rt<<1|1].add+=tmp;
        tree[rt<<1|1].val+=1LL*(tree[rt<<1|1].r-tree[rt<<1|1].l+1)*tmp;
        tree[rt].add=0;
    }
}
void build(int rt,int l,int r)
{
    tree[rt].l=l;
    tree[rt].r=r;
    tree[rt].add=0;
    if(l==r)
    {
        tree[rt].val=a[l];
        return ;
    }
    int mid=tree[rt].mid=l+r>>1;
    build(rt<<1,l,mid);
    build(rt<<1|1,mid+1,r);
    up(rt);
}
void update(int rt,int l,int r,ll val)
{
    if(tree[rt].l>r||tree[rt].r<l) return ;
    if(tree[rt].l>=l&&tree[rt].r<=r)
    {
        tree[rt].add+=val;
        tree[rt].val+=1LL*(tree[rt].r-tree[rt].l+1)*val;
        return ;
    }
    down(rt);
    if(tree[rt].mid>=l) update(rt<<1,l,r,val);
    if(tree[rt].mid<r) update(rt<<1|1,l,r,val);
    up(rt);
    return ;
}
ll query(int rt,int pos)
{
    if(tree[rt].l==tree[rt].r) return tree[rt].val;
    down(rt);
    if(pos<=tree[rt].mid) return query(rt<<1,pos);
    else return query(rt<<1|1,pos);
}
int l[maxn],r[maxn],val[maxn],cnt[maxn];
int tt[maxn];
int main()
{
    int n,m,k;
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    build(1,1,n);
    for(int i=1;i<=m;i++) scanf("%d%d%d",&l[i],&r[i],&val[i]);
    for(int i=1;i<=k;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        tt[u]++;
        tt[v+1]--;
    }
    int tmp=0;
    for(int i=1;i<=m;i++)
    {
        tmp+=tt[i];
        cnt[i]=tmp;
    }
    for(int i=1;i<=m;i++) update(1,l[i],r[i],1LL*cnt[i]*val[i]);
    for(int i=1;i<=n;i++) printf("%lld ",query(1,i));
    return 0;
}
做法二：
#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn = 2e5+5;
int a[maxn];
int l[maxn],r[maxn],val[maxn],cnt[maxn];
int tt[maxn];
ll sum[maxn];
int main()
{
    int n,m,k;
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    for(int i=1;i<=m;i++) scanf("%d%d%d",&l[i],&r[i],&val[i]);
    for(int i=1;i<=k;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        tt[u]++;
        tt[v+1]--;
    }
    int tmp=0;
    for(int i=1;i<=m;i++)
    {
        tmp+=tt[i];
        cnt[i]=tmp;
    }
    ll tp=0;
    for(int i=1;i<=m;i++)
    {
        sum[l[i]]+=1LL*cnt[i]*val[i];
        sum[r[i]+1]-=1LL*cnt[i]*val[i];
    }
    for(int i=1;i<=n;i++)
    {
        tp+=sum[i];
        printf("%lld ",a[i]+tp);
    }
    return 0;
}

线段树第八题：

链接：

http://codeforces.com/contest/444/problem/C

题意：

给你n个元素，第i个元素最初的颜色是i，最初每个元素的权值为0,有两种操作，第一种操作是区间赋值x，如果之前元素的颜色为y,那么赋值之后他的权值增加abs(x-y)，第二种操作是查询所有元素的权值和。

做法：

首先可以想象如果每次操作区间很大，那么所有元素趋向颜色相同，如果操作区间很小，则可以暴力更新，那么我们可以维护区间颜色是否相同，如果相同则用lazy进行更新，否则再去子区间进行更新，这里要注意lazy对于子区间的更新每次都有一个权值的增加，这个也要用一个lazy数组维护一下。

代码：

#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn = 1e5+5;
struct T
{
    int l,r,mid;
    int col,add;
    ll sum,inc;
}tree[maxn<<2];
int col[maxn];
void up(int rt)
{
    if(tree[rt<<1].col==tree[rt<<1|1].col) tree[rt].col=tree[rt<<1].col;
    else tree[rt].col=0;

    tree[rt].sum=tree[rt<<1].sum+tree[rt<<1|1].sum;
}
int maxx=0;
void down(int rt)
{
    if(tree[rt].add!=0)
    {
        int tmp=tree[rt].add;
        tree[rt<<1].col=tmp;
        tree[rt<<1].add=tmp;

        tree[rt<<1|1].col=tmp;
        tree[rt<<1|1].add=tmp;
        tree[rt].add=0;
    }

    if(tree[rt].inc!=0)
    {
        ll tmp=tree[rt].inc;
        tree[rt<<1].sum+=1LL*tmp*(tree[rt<<1].r-tree[rt<<1].l+1);
        tree[rt<<1].inc+=tmp;
        tree[rt<<1|1].sum+=1LL*tmp*(tree[rt<<1|1].r-tree[rt<<1|1].l+1);
        tree[rt<<1|1].inc+=tmp;

        tree[rt].inc=0;
    }

}
void build(int rt,int l,int r)
{
    tree[rt].l=l;
    tree[rt].r=r;
    tree[rt].add=0;
    tree[rt].inc=0;
    if(l==r)
    {
        tree[rt].col=col[l];
        tree[rt].sum=0;
        return ;
    }
    int mid=tree[rt].mid=l+r>>1;
    build(rt<<1,l,mid);
    build(rt<<1|1,mid+1,r);
    up(rt);
    return ;
}
void update(int rt,int l,int r,int co)
{
    if(tree[rt].l>r||tree[rt].r<l) return ;
    if(tree[rt].l>=l&&tree[rt].r<=r&&tree[rt].col!=0)
    {
        tree[rt].sum=tree[rt].sum+1LL*abs(co-tree[rt].col)*(tree[rt].r-tree[rt].l+1);
        tree[rt].inc+=abs(co-tree[rt].col);
        tree[rt].col=co;
        tree[rt].add=co;
        return ;
    }
    down(rt);
    if(tree[rt].mid>=l) update(rt<<1,l,r,co);
    if(tree[rt].mid<r) update(rt<<1|1,l,r,co);
    up(rt);
}
ll query(int rt,int l,int r)
{
    if(tree[rt].l>r||tree[rt].r<l) return 0;
    if(tree[rt].l>=l&&tree[rt].r<=r) return tree[rt].sum;
    down(rt);
    ll ans=0;
    if(tree[rt].mid>=l) ans=ans+query(rt<<1,l,r);
    if(tree[rt].mid<r) ans=ans+query(rt<<1|1,l,r);
    return ans;
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) col[i]=i;
    build(1,1,n);
    int cnt=0;
    while(m--)
    {
        int op,x,y,z;
        scanf("%d",&op);
        if(op==1)
        {
            scanf("%d%d%d",&x,&y,&z);
            update(1,x,y,z);
        }
        else
        {
            scanf("%d%d",&x,&y);
            printf("%lld\n",query(1,x,y));
        }
    }
    return 0;
}

线段树第九题：

链接：

https://codeforces.com/contest/707/problem/D

题意

有n个书架，每个书架上有m个位置可以放书，现在要维护4种操作。
1,x,y:如果第x个书架的第y个位置没有书，在第x个书架的第y个位置放置一本书
2,x,y:如果第x个书架的第y个位置有书，把第x个书架的第y个位置的书拿走
3,x: 将第x书架所有有书的位置的书拿走，将x书架所有没有书的位置放上书
4,x:返回第x次操作后状态
要求每步操作之后返回当前书的个数。

做法

首先每一步操作都是从之前的某步操作转过来的，所以整个操作顺序是一颗有向树，我们只要按顺序dfs，问题就变成单点更新，区间求和，但是要注意的是，回溯撤销操作的时候要看操作的时候是否对状态进行改变，比如本来有书又放一本书，没有对状态进行改变，回溯操作的时候就不能取走这本书。

代码


#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn = 1e6+5;
struct data
{
    int op;
    int x,y;
}Q[maxn];
int n,m,q;
struct T
{
    int l,r,mid;
    int sum,add;
}tree[maxn<<2];
vector<int>G[maxn];
void down(int rt)
{
    if(tree[rt].add)
    {
        tree[rt<<1].sum=(tree[rt<<1].r-tree[rt<<1].l+1)-tree[rt<<1].sum;
        tree[rt<<1|1].sum=(tree[rt<<1|1].r-tree[rt<<1|1].l+1)-tree[rt<<1|1].sum;
        tree[rt<<1].add=1-tree[rt<<1].add;
        tree[rt<<1|1].add=1-tree[rt<<1|1].add;
        tree[rt].add=0;
    }
}
void up(int rt)
{
    tree[rt].sum=tree[rt<<1].sum+tree[rt<<1|1].sum;
}
void build(int rt,int l,int r)
{
    tree[rt].l=l;
    tree[rt].r=r;
    tree[rt].sum=0;
    tree[rt].add=0;
    if(l==r) return;
    int mid=tree[rt].mid=l+r>>1;
    build(rt<<1,l,mid);
    build(rt<<1|1,mid+1,r);
}
bool update(int rt,int pos,int val)
{
    if(tree[rt].l==tree[rt].r)
    {
        int tt=tree[rt].sum;
        tree[rt].sum=val;
        return (tt!=val);
    }
    down(rt);
    bool ans;
    if(tree[rt].mid>=pos) ans=update(rt<<1,pos,val);
    else ans=update(rt<<1|1,pos,val);
    up(rt);
    return ans;
}
void update_(int rt,int l,int r)
{
    if(tree[rt].l>r||tree[rt].r<l) return ;
    if(tree[rt].l>=l&&tree[rt].r<=r)
    {
        tree[rt].add=1-tree[rt].add;
        tree[rt].sum=tree[rt].r-tree[rt].l+1-tree[rt].sum;
        return ;
    }
    down(rt);
    if(tree[rt].mid>=l) update_(rt<<1,l,r);
    if(tree[rt].mid<r) update_(rt<<1|1,l,r);
    up(rt);
}
int ans[maxn];
void dfs(int rt)
{
    int flag=0;
    if(rt!=0)
    {
        if(Q[rt].op==1)
        {
            if(update(1,(Q[rt].x-1)*m+Q[rt].y,1)) flag=1;
        }
        else if(Q[rt].op==2)
        {
            if(update(1,(Q[rt].x-1)*m+Q[rt].y,0)) flag=1;
        }
        else if(Q[rt].op==3) update_(1,(Q[rt].x-1)*m+1,Q[rt].x*m);
    }
    ans[rt]=tree[1].sum;
    for(int i=0;i<G[rt].size();i++)
    {
        dfs(G[rt][i]);
    }
    if(rt!=0)
    {
        if(Q[rt].op==1&&flag==1) update(1,(Q[rt].x-1)*m+Q[rt].y,0);
        else if(Q[rt].op==2&&flag==1) update(1,(Q[rt].x-1)*m+Q[rt].y,1);
        else if(Q[rt].op==3) update_(1,(Q[rt].x-1)*m+1,Q[rt].x*m);
    }
}
int main()
{
    scanf("%d%d%d",&n,&m,&q);
    for(int i=1;i<=q;i++)
    {
        scanf("%d",&Q[i].op);
        if(Q[i].op==1||Q[i].op==2)
        {
            G[i-1].push_back(i);
            scanf("%d%d",&Q[i].x,&Q[i].y);
        }
        else if(Q[i].op==3)
        {
            G[i-1].push_back(i);
            scanf("%d",&Q[i].x);
        }
        else
        {
            scanf("%d",&Q[i].x);
            G[Q[i].x].push_back(i);
        }
    }
    build(1,1,n*m);
    dfs(0);
    for(int i=1;i<=q;i++) printf("%d\n",ans[i]);
    return 0;
}
线段树专题
far away
08-16 820
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1166 敌兵布阵 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 97473    Accepted Submi
CodeForces---787D：Legacy【线段树优化建图+最短路】
KobeDuu
06-16 583
题目： 戳这里啊~~~ 题意： 给你三种操作：（1）点到点建边；（2）点到区间建边；（3）区间到点建边；最后求起点到其他点的最短距离 分析： 最短距离无非建边跑Dijkstra即可，考虑如何对区间建边，如果直接对区间的每一点建边，那N^2的复杂度是行不通的，考虑将区间映射到线段树上的一个点： （1）建两颗线段树，一颗表示出度的点，一颗表示入度的点 （2）对于表示出度的树，对每一节点和...
【CodeForces】240F - TorCoder 线段树
poursoul
07-19 1200
传送门：【CodeForces】240F - TorCoder 题目大意：gei n
codeforces 914D(线段树)
Everything can be done!
01-21 1013
题意： 1单点更新 2查询[l,r]区间的值最多改变一个能不能使得区间的gcd等于给出的x,但是此改变不改变原来的值。 思路：线段树维护gcd，很简单。查询的时候可以维护一个cnt的值，表示为当一个点的值不整除x的时候，对数进行改变的个数。当cnt>1的时候，直接结束函数。 #include using namespace std; const int maxn = 5e5 +
Codeforces--1234D--线段树
weixin_44083561的博客
03-04 248
题意：先给你一个字符串，然后对这个字符串有些操作，1 x a就是把x位置上的字符替换成a，2 x y就是问区间[x,y]上有多少个不同的字符； 用1<<(s[i]-‘a’)代表这个字符，用线段树去维护，注意是用| #include <cstdio> #include <algorithm> #include <cstring> #include &l...
Codeforces 1108 E2（线段树+思维）
weixin_30328063的博客
02-01 165
传送们 题意: 给你一个长度为nnn的数列bbb、以及mmm个区间。 你可以选取111个或多个这样的区间aia_iai​，使得令区间aia_iai​所对应的所有值bib_ibi​都减111。你最终要使得max⁡i=1nbi−min⁡i=1nbi\max\limits...
codeforces 339D 简单的线段树操作
黑码
08-10 924
Xenia the beginner programmer has a sequence a, consisting of 2n non-negative integers: a1, a2, …, a2n. Xenia is currently studying bit operations. To better understand how they work, Xenia decided to
CodeForces_1348EF – Phoenix and Memory 贪心+线段树找区间最小值
01-03
这题如果没有输出2个解就很简单。 是个之前做过的类型： 把所有限制按R排序， 然后每次取出R最小的，然后从其L开始选，尽量选能选的中最小的。 这样选如果能选完，就说明有解。 贪心正确性显然：R大的至少可以选则R...
linkfqy#优快云_blog_backup#【贪心+线段树】Codeforces 557C Arthur and Tabl
07-25
暴枚最长桌脚的长度$l$，然后长度比$l$长的桌脚全部都要砍掉长度比$l$短的桌脚选择代价前$k$小的砍掉用线段树维护;示例程序 ：typedef long l
Codeforces 1373G Hall 定理 + 线段树
neweryyy的博客
04-01 493
题意 传送门 Codeforces 1373G Pawns 题解 棋子 (x,y)(x,y)(x,y) 能安排在 y≤∣k−y∣+xy\leq \lvert k-y\rvert + xy≤∣k−y∣+x 的位置。 令 f(j)f(j)f(j) 代表 i≥ji\geq ji≥j 必须安排的棋子数量，那么对于合法的最大行号 ttt，应该满足 f(j)≤t−j+1f(j)\leq t - j + 1f(j)≤t−j+1。根据 Hall 定理，将 f(j)f(j)f(j) 看作二分图需要构造完备匹配的一侧点集（显然
CodeForces - 447E DZY Loves Fibonacci Numbers （线段树）
qq_43900769的博客
03-06 1050
题意：在一个序列中有两种操作：第一种是修改操作，在某个区间加上斐波那契数列的一段；第二种是查询操作，查询某个区间的区间和。 E. DZY Loves Fibonacci Numbers time limit per test4 seconds memory limit per test256 megabytes inputstandard input outputstandard output I...
codeforces 线段树题单
apple_52197802的博客
07-27 1049
线段树
[ 线段树 ] Codeforces903G
gjghfd
12-16 531
转换成求最小割，线段树维护就好了。#include<bits/stdc++.h> using namespace std; typedef long long ll; const int N=200010; ll c[N<<2],p[N<<2],f[N]; int k,n,m,Q; int a[N]; int t[N],nx[N],w[N],h[N],num; int x,y,z; inline v
CodeForces - 242E 线段树 好题
Barry&Liu
08-22 392
E. XOR on Segment time limit per test 4 seconds memory limit per test 256 megabytes input standard input output standard output You've got an array a, consisting of n integers a1, a2, ..., an...
Codeforces 1642E 线段树
neweryyy的博客
02-27 711
题意 传送门 Codeforces 1642E Anonymity Is Important 题解 对于 t=0t=0t=0 的询问，若 x=0x=0x=0，则区间内所有人的状态是确定的，即都没有生病。使用 std::set 维护状态仍不确定的人的集合，通过二分求 [l,r][l,r][l,r]，就可以 O(log⁡n)O(\log n)O(logn) 将明确状态为没有生病的人从集合中删除。 若存在一个 x=1x=1x=1 的区间 [l,r][l,r][l,r]，满足 l≤i≤rl\leq i\leq rl
Codeforces Beza‘s Hangover（线段树）
不爱吃鱼的猫丶的博客
07-12 245
题意   给出三个数n,m,q,分别代表初始n个小时里每个小时喝的什么酒，m代表有m种酒（注意：m中可能出现n中没有出现过的酒），记录这些酒的容量，q次询问。   询问的时候有两种情况， · 1 X Y 代表把第X小时喝的酒换成名字为Y的酒 · 2 L R 表示判断第L小时到第R小时这R-L+1个小时里喝的酒能否让Beza宿醉，如果喝的毫升数小于等于喝酒时间（单位：分钟）的一半不醉，否则醉 思路 线段树模板题，单点修改，区间求和，判断区间和是否小于等于区间时间的一半就ok。 cin卡TLE 77了，sca.
codeforces 787D Legacy （线段树）
天际苍穹的博客
07-19 621
题目链接：http://codeforces.com/problemset/problem/787/D Description Rick and his co-workers have made a new radioactive formula and a lot of bad guys are after them. So Rick wants to give his legacy t...
Codeforces482B【线段树构造】
weixin_30843605的博客
09-13 148
题意： 有M个限制，每个限制有l，r，q，表示从a[l]~a[r]取且后的数一定为q，问是否有满足的数列。 思路： 看到大牛说是线段树，线段树对于区间操作，印象中乘啊，+啊，-啊都不错，但是并没有就是对于这个位运算就不懂了； 这题的题意就是构造，大致思路是 每条限制是对于每个区间处理就是或上q（可以保证相应的二进制一定是1），然后用线段树处理完m个限制，最后还要询问一...
HDU 300+AC代码解析：大数、线段树、字符串与动态规划
代码可能涉及大数计算、线段树的应用、字符串操作优化以及动态规划等算法。这样的资源对于准备参加算法竞赛、面试中的算法题目，或是提升编程能力的学习者而言是非常宝贵的。 另外需要注意的是，尽管题目提到了“AC...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值