线段树练习题

最新推荐文章于 2022-08-17 16:24:19 发布
最新推荐文章于 2022-08-17 16:24:19 发布
阅读量133 收藏 2
点赞数
分类专栏： acm 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhoucheng_123/article/details/120452621
版权

poj-3667–hotel
整体来说思路不难想，就是细节比较多，处理复杂，容易出错

题意：给出长为n的空间大小，支持两种操作
1.给定长度len,尽可能填补靠左边的空间，并输出填补的起始位置
2.给定起始位置pos，以及长度len，将以pos为起始长度为len的空间清空

思路：

变量记录：
维护三颗线段树，seg_left[root]表示结点root对应的区间[l,r]上，从左端点l起始的空闲空间长度，seg_right[root]表示结点root对应的区间[l,r]上，从右端点r起始的空闲空间长度,seg_tree[root]表示结点root对应的区间[l,r]上，对应的最大的连续空闲长度。
lazy[root]表示结点root对应的区间[l,r]上，对应的懒标记，这里需要注意的点是，有三种状态，值为2时表示root结点下的子树都为被占状态，值为1时表示root结点下的子树都为空闲状态，两种后来的可以覆盖前面的，值为0表示没有进行标记。
细节处理方面比较多：
1.push_up向上回溯的处理
2.query查询时的处理，先查左子树，再查左子树加上右子树，最后查右子树
3.lazy tag的部分，push_down向下push比较简单，就是将三颗树的值都置为lazy的值就可以。

//#include <bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

#define int long long
#define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
const int N = 2e5+10;
int n;
int arr[N],seg_tree[N<<2],lazy[N<<2],seg_left[N<<2],seg_right[N<<2];
void push_up(int root,int L,int R)
{
    seg_tree[root]=seg_right[root<<1]+seg_left[root<<1|1];
    seg_tree[root]=max(seg_tree[root],max(seg_tree[root<<1],seg_tree[root<<1|1]));
    int mid=L+R>>1;
    if(seg_left[root<<1]==mid-L+1)
    seg_left[root]=seg_left[root<<1]+seg_left[root<<1|1];
    else seg_left[root]=seg_left[root<<1];

    if(seg_right[root<<1|1]==R-mid)
    seg_right[root]=seg_right[root<<1]+seg_right[root<<1|1];
    else seg_right[root]=seg_right[root<<1|1];
}
void build(int root,int L,int R)
{
    if(L==R)
    {
        seg_tree[root]=1;
        seg_left[root]=1;
        seg_right[root]=1;
        return ;
    }
    int mid=(L+R)>>1;
    build(root<<1,L,mid);
    build(root<<1|1,mid+1,R);
    push_up(root,L,R);
}
void add(int root,int L,int R,int val)
{
    seg_tree[root]=(val-1)*(R-L+1);
    seg_left[root]=(val-1)*(R-L+1);
    seg_right[root]=(val-1)*(R-L+1);
}
void push_down(int root,int L,int R)
{
    if(lazy[root])
    {
        int mid=L+R>>1;
        lazy[root<<1]=lazy[root];
        lazy[root<<1|1]=lazy[root];
        add(root<<1,L,mid,lazy[root]);
        add(root<<1|1,mid+1,R,lazy[root]);
        lazy[root]=0;
    }
}

void update_Interval(int root,int L,int R,int LL,int RR,int val)
{
    if(LL>R||RR<L)return ;
    int mid=L+R>>1;
    if(LL<=L&&RR>=R)
    {
        //if(L==R&&L==6)cout<<"fuck"<<endl;
        lazy[root]=val;
        seg_tree[root]=(R-L+1)*(val-1);
        seg_left[root]=(R-L+1)*(val-1);
        seg_right[root]=(R-L+1)*(val-1);
        //lazy标记只是标记当前已加了值，但是还没下传的，所以这里不是*lazy[root]
        //lazy[root]表示的是儿子节点需要加的值
        return ;
    }
    //up和down需要对应，因为up是通过儿子结点对当前节点进行更新
    //所以，pushdown要保证儿子的值已经更新了。
    push_down(root,L,R);

    update_Interval(root<<1,L,mid,LL,RR,val);
    update_Interval(root<<1|1,mid+1,R,LL,RR,val);
    push_up(root,L,R);
}
int ans;
void query(int root,int L,int R,int LL,int RR,int x)
{
    if(LL>R||RR<L)return  ;
    /*if(x==4)
    cout<<L<<" "<<R<<" "<<seg_tree[root]<<endl;*/
    int mid=L+R>>1;
    push_down(root,L,R);
    if(LL<=L&&RR>=R)
    {
        if(L==R)
        {
            ans=L;
            update_Interval(1,1,n,L,L,1);
            return ;
        }
        if(seg_tree[root<<1]>=x)
        {
            query(root<<1,L,mid,LL,RR,x);
        }

        else if(seg_right[root<<1]+seg_left[root<<1|1]>=x)
        {
            int pos;
            pos=mid-seg_right[root<<1]+1;
            //cout<<"update"<<pos<<pos+x-1<<endl;
            update_Interval(1,1,n,pos,pos+x-1,1);
            ans=pos;
            return ;
        }


        else
        {
            query(root<<1|1,mid+1,R,LL,RR,x);
        }

    }
    //push_down(root,L,R);
    push_up(root,L,R);

    //return min(query(root<<1,L,mid,LL,RR,x),query(root<<1|1,mid+1,R,LL,RR,x));
}
void update(int root,int L,int R,int pos,int val)
{
    if(pos<L||pos>R)return ;
    if(L==R&&L==pos)
    {
        seg_tree[root]=val;
        return ;
    }
    int mid=L+R>>1;
    update(root<<1,L,mid,pos,val);
    update(root<<1|1,mid+1,R,pos,val);
    push_up(root,L,R);
}
void func()
{
    cout<<"-------start--------------"<<endl;
    cout<<seg_tree[1]<<endl;
    cout<<seg_tree[2]<<"   "<<seg_tree[3]<<endl;
    cout<<seg_tree[4]<<" "<<seg_tree[5]<<" "<<seg_tree[6]<<" "<<seg_tree[7]<<endl;

    /*cout<<seg_tree[3]<<endl;
    cout<<seg_tree[6]<<"   "<<seg_tree[7]<<endl;
    cout<<seg_tree[12]<<" "<<seg_tree[13]<<" "<<seg_tree[14]<<" "<<seg_tree[15]<<endl;
    cout<<"--------end---------------"<<endl;*/
}

signed main()
{
    ios
    int m;
    cin>>n>>m;
    build(1,1,n);
    while(m--)
    {
        int flag,x,y;
        cin>>flag;
        if(flag==1)
        {
            cin>>x;
            if(seg_tree[1]<x)
            {
                cout<<0<<endl;
            }
            else
            {
                query(1,1,n,1,n,x);
                cout<<ans<<endl;
            }
            //cout<<seg_tree[1]<<endl;
        }
        else
        {
            cin>>x>>y;
            update_Interval(1,1,n,x,x+y-1,2);
        }
        /*cout<<"总共 "<<seg_tree[1]<<endl;
        func();*/
    }
    return 0;
}

/*
9 100
1 3
1 3
1 3
2 1 9
1 3

*/

icpc网络预选赛②L Euler Function

在这里插入图片描述
在这里插入图片描述

思路：
由将要乘的数分解质因数，一个一个乘，对于因子已经包含x的区间，直接裸区间乘，不包含的区间，可以再次深入找，直到单点修改（为什么这样不超时，因为100以内只有25个质数，区间范围为1e5，也就是说最多单点修改251e5log1e5次，是可以的）。

#include <bits/stdc++.h>

using namespace std;

#define int long long
#define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
const int N = 1e5+10;
int arr[N],lazy[N<<2],seg_tree[N<<2];
int n,m,p=998244353;
int seg_vis[N][30];
int fi[101];
int prime[30];
int inde;
int prime_index[105];//素数的位置，例如prime_index[2]=0

struct node
{
    int zhi[30];
    int len;
}fenjie[105];


void fenjiezhi()
{
    for(int i=2;i<=100;i++)
    {
        int j=0;
        int x=i;
        while(j<inde&&x!=1)
        {
            if(x%prime[j]==0)
            {
                fenjie[i].zhi[fenjie[i].len++]=prime[j];
                while(x%prime[j]==0)
                {
                    x/=prime[j];
                }
            }
            j++;
        }
    }
}
void push_up(int root,int L,int R)
{
    seg_tree[root]=(seg_tree[root<<1]+seg_tree[root<<1|1])%p;
    for(int i=0;i<25;i++)
    {
        seg_vis[root][i]=min(seg_vis[root<<1][i],seg_vis[root<<1|1][i]);
    }
}
void build(int root,int L,int R)
{
    lazy[root]=1;

    if(L==R)
    {
        int x=arr[L];
        seg_tree[root]=x;

        for(int i=0;i<fenjie[x].len;i++)
        {
            int tmp_prime=fenjie[x].zhi[i];
            seg_vis[root][prime_index[tmp_prime]]=1;
            seg_tree[root]=seg_tree[root]*(tmp_prime-1)/tmp_prime;
        }
        return ;
    }
    int mid=(L+R)>>1;
    build(root<<1,L,mid);
    build(root<<1|1,mid+1,R);
    push_up(root,L,R);
}
void add(int root,int L,int R,int val)
{
    lazy[root]=lazy[root]*val%p;
    seg_tree[root]=seg_tree[root]*val%p;
}
void push_down(int root,int L,int R)
{
    //if(lazy[root]!=0)
    //if(root==2)cout<<"fuck"<<lazy[root][0]<<endl;
    if(lazy[root]!=1)
    {
        int mid=L+R>>1;
        add(root<<1,L,mid,lazy[root]);
        add(root<<1|1,mid+1,R,lazy[root]);
    }

    lazy[root]=1;

    //if(root==2)cout<<"fuck"<<lazy[root][0]<<endl;
}

void update_Interval(int root,int L,int R,int LL,int RR,int val)
{
    if(LL>R||RR<L)return ;
    //cout<<L<<" "<<R<<endl;
    int mid=L+R>>1;
    if(LL<=L&&RR>=R)
    {

        int index=prime_index[val];//得到质数的下标
        if(L==R)
        {
            if(seg_vis[root][index]==1)seg_tree[root]=seg_tree[root]*(val)%p;
            else seg_tree[root]=seg_tree[root]*(val-1)%p;
            seg_vis[root][index]=1;
            return ;
        }
        if(seg_vis[root][index])
        {
            seg_tree[root]=seg_tree[root]*val%p;
            lazy[root]=lazy[root]*val%p;
            return ;
        }
        //lazy标记只是标记当前已加了值，但是还没下传的，所以这里不是*lazy[root]
        //lazy[root]表示的是儿子节点需要加的值
    }
    //up和down需要对应，因为up是通过儿子结点对当前节点进行更新
    //所以，pushdown要保证儿子的值已经更新了。
    push_down(root,L,R);

    update_Interval(root<<1,L,mid,LL,RR,val);
    update_Interval(root<<1|1,mid+1,R,LL,RR,val);
    push_up(root,L,R);
}
int query(int root,int L,int R,int LL,int RR)
{
    if(LL>R||RR<L)return  0;
    int mid=L+R>>1;
    if(LL<=L&&RR>=R)
    {
        return seg_tree[root]%p;
    }
    push_down(root,L,R);
    return (query(root<<1,L,mid,LL,RR)+query(root<<1|1,mid+1,R,LL,RR))%p;
}
/*
void update(int root,int L,int R,int pos,int val)
{
    if(pos<L||pos>R)return ;
    if(L==R&&L==pos)
    {
        seg_tree[root]=val;
        arr[L]=val;
        return ;
    }
    int mid=L+R>>1;
    update(root<<1,L,mid,pos,val);
    update(root<<1|1,mid+1,R,pos,val);
    push_up(root,L,R);
}
void func()
{
    cout<<"-------start--------------"<<endl;
    cout<<seg_tree[1]<<endl;
    cout<<seg_tree[2]<<"   "<<seg_tree[3]<<endl;
    cout<<seg_tree[4]<<" "<<seg_tree[5]<<" "<<seg_tree[6]<<" "<<seg_tree[7]<<endl;
    cout<<seg_tree[8]<<" "<<seg_tree[9]<<endl;
    cout<<"--------end---------------"<<endl;
    cout<<seg_tree[3]<<endl;
    cout<<seg_tree[6]<<"   "<<seg_tree[7]<<endl;
    cout<<seg_tree[12]<<" "<<seg_tree[13]<<" "<<seg_tree[14]<<" "<<seg_tree[15]<<endl;

}*/
signed main()
{
    ios
    for(int i=1;i<=100;i++)
    {
        int sum=1;
        //int flag=1;
        for(int j=2;j<i;j++)
        {
            if(__gcd(i,j)==1)sum++;

        }
        fi[i]=sum;
        if(fi[i]==i-1)
        {
            prime[inde]=i;
            prime_index[i]=inde++;
        }
        //cout<<i<<" "<<sum<<endl;
    }
    //cout<<inde<<endl;
    fenjiezhi();
    //for(int i=0;i<=100;i++)
        //cout<<"i="<<i<<" "<<prime_index[i]<<endl;
    //cout<<fenjie[8].len;
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        cin>>arr[i];
    build(1,1,n);
    //func();
    while(m--)
    {
        int flag,x,y,k;
        cin>>flag;
        if(flag==0)
        {
            cin>>x>>y>>k;
            int zhi=k;
            for(int i=0;i<fenjie[k].len;i++)
            {
                int tmp_prime=fenjie[k].zhi[i];//分解的每一个质数

                //lazy[root][index]++;//对应的懒标记++记录
                while(zhi%tmp_prime==0)
                {
                    update_Interval(1,1,n,x,y,tmp_prime);
                    zhi/=tmp_prime;
                }
            }
        }
        else
        {
            cin>>x>>y;
            cout<<query(1,1,n,x,y)<<endl;
        }
        //func();
    }
    return 0;
}

/*


*/
nefu_zc
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线段树 (经典题目合集)
繁凡さん的博客
02-11 1380
P3372 【模板】线段树 1 #include<bits/stdc++.h> using namespace std; typedef long long ll; const ll N=1e5+7; const ll mod=2147483647; ll n,m; struct node { ll l,r,sum,lz; }tree[N]; ll arr[N]; void b...
最全线段树例题
yihanyifan的博客
09-23 958
例题1： 给一个长度n的序列,对于每个询问 询问区间内最大连续和 一、一个区间的最大子段和有三种情况 1、左子区间的最大子段和 2、右子区间的最大子段和 3、横跨左右子区间 二、每个结点需要维护的信息 1、区间和sum 2、从区间左端点开始的最大子段和lgss 3、从区间右端点开始的最大子段和rgss 4、区间最大子段和gss 三、建树 1、遇到叶子节点就...
线段树总结（题目合集）
常胜将军的博客
08-19 1270
1、POJ 3321 题意：给出一个苹果树，每个节点一开始都有苹果。C X，如果X点有苹果，则拿掉，如果没有，则新长出一个。Q X，查询X点与它的所有后代分支一共有几个苹果。 分析：利用dfs序将子树节点变成连续区间，然后利用线段树进行单点修改、区间求和就好了。注意vector<int> g[N]会超时，改成vector<vector<int> > g就好了...
线段树题目整合
hao_zong_yin的博客
07-25 3853
1.hdu1166 敌兵布阵 更新节点,区间求和。 2.hdu1754 I Hate It 更新节点,区间最值. . 3.hdu1698 Just a Hook 成段更新,总区间求和. . 4.hdu1394 Minimum Inversion Number 更新节点,区间求和 . 5.hdu1779 9-Problem C暂不公开 成段更新,区间最值
ACM 线段树，树状数组入门题（附代码解释）
不二君
08-15 422
如果是初学者建议先看看这篇博客，写的很不错传送门 目录 HDU 1166 敌兵布阵（线段树） HDU 1698 Just a Hook（线段树） POJ 3468 A Simple Problem with Integers（线段树区间修改+求和） HDU 1540 Tunnel Warfare（最长连续区间+单点修改） 洛谷 P3372 【模板】线段树 1 洛谷 P3373 【模板...
c++数据结构进阶线段树习题
最新发布
07-05
在给定的线段树习题中，有四个具体任务： 1. **区间最大连续子段和**：给定一个数组，需要支持两种操作：查询某区间的最大连续子段和，以及修改数组中的某个元素。线段树可以构建为存储每个区间内的最大子段和，...
线段树练习POJ 3264
04-14
线段树是一种数据结构，常用于处理区间查询与更新的问题，它能高效地支持动态维护区间最值、求和等问题。在本题“POJ 3264”中，我们可能面临的是一个区间最值或者区间求和的计算任务。线段树的基本思想是将数组或...
线段树动态问题
07-17
如何解决动态范围求和问题，如何简单地了解线段树。 附有模板以及习题
线段树学习步骤
08-09
掌握线段树的关键在于多做题和实践。通过解决各种线段树题目，可以加深理解，熟练运用。同时，了解不同问题的优化技巧，如懒惰标记、线性时间构建等，能进一步提升解题效率。 总的来说，学习线段树需要理解其基本...
几道经典线段树题目及代码
07-22
线段树，作为一种高效的数据结构，广泛应用于计算机科学和算法设计中，特别是在处理区间查询和更新问题时。它能够以O(logN)的时间复杂度完成区间内的查询与修改操作，大大提高了程序的运行效率。本资源包含了一些...
线段树入门+例题
屋檐听雨丶
08-03 514
线段树入门 最近预备队里教了线段树，刚学的时候只是觉得神奇，但是还是有点迷，后来自己对这个数据结构进行了琢磨，发现真的是非常的巧妙。正好趁热打铁，对线段树总结一下。 为什么需要线段树？ 假设我们有一个数组arr，对于这个数组，我们有两种操作，第一种操作就是求从arr数组从某一区间的和，第二种操作就是修改arr中的某一个值或者是修改某一区间的值。 针对此问题，我们最简单的有两种方法。 **第一种：**对于修改操作，我们可以直接改变该位置的值，这种时间复杂度为o(1),但是对于求和，我们需要arr[i]+arr
codeforces 线段树题单
apple_52197802的博客
07-27 806
线段树
[线段树总结题单]
MagicFromMe的博客
08-17 148
接下来思考移动了第一个数后逆序对的变化：假设在x这个位置，x-n中比它大的数为m个，那么比它小的数有n-m-1个，那么当它移动到末尾的时候，之前比它大的数会和它构成逆序对，那么逆序对的数目会增加，但是之前比它小的，在移动之前跟它构成逆序对，移动了之后逆序对会减少，所以移动之后的逆序对数目是（cnt表示初始的逆序对数目）：cnt - （n-m-1) + m；（如果a[i]的范围不是1-n的话，我们可以进行离散化在求）。......
线段树经典题目（一定要做完）
bggl的博客
05-12 6538
最近学习了好久的线段树，对线段树有了初步的基础的认知，为了巩固知识点找几道基础题练练手 1.hdu1166 敌兵布阵 http://acm.hdu.edu.cn/showproblem.php?pid=1166 思路：线段树基础模版题（点修改+区间查询） #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;algorith...
线段树题单及代码详解
Suryxin's blogs
08-03 301
P3372 【模板】线段树 1 题目描述： 区间修改 区间查询 如题，已知一个数列，你需要进行下面两种操作： 将某区间每一个数加上 kk。 求出某区间每一个数的和。 思路： 最模版的线段树，没什么好说的 写几个函数： 建树 标记下传 区间修改 区间查询 板子： #include<map> #include<set> #include<stack> #include<queue> #include<cmath> #include&lt
线段树专辑(转)
黄廉政的专栏
08-04 1329
线段树专辑<br />这几天陆陆续续更新了下边几道我所能找到得具有一些代表性的线段树题目<br />从最最简单的区间求和到对区间的各种操作都包涵在这些题目里了<br />相信对一些准备学习线段树的人有一定得帮助<br />突然发现自己对数据结构的题目非常有感觉,所以在刷下边的题的同时也生出灵感出了好几道线段树题目<br />等比赛结束后也会陆续加进里边<br /><br />快半年过去代码风格也有很大的改变，感觉以前写的代码很不规范，用自己在预定义中定义的一些函数，但后来感觉作用不是很大，所以又删去了，所以
线段树习题集
天亮说晚安
02-17 3820
线段树习题集 大部分来源于@NotOnlySuccess  一、点修改 最最基础的线段树,只更新叶子节点,然后把信息用PushUp(int rt)这个函数更新上来 hdu1166 敌兵布阵 线段树功能:update:单点增减 query:区间求和 解题报告 hdu1754 I Hate It 线段树功能:update:单点替换 query:区间最值 解
线段树强化题单（欢迎补充）
一只可怜的小菜鸡的博客
02-20 352
1，poj 1151 Atlantis： 求矩形面积交。 2，poj 1177 Picture： 求矩形轮廓的周长。 3，poj 1389 Area of Simple Polygons ：同第一题。 4，poj 1823 Hotel ：线段树线段的插入删除求线段树中最长的线段长度 5，poj 2104 K-th Number：线段树维护归并排序树+三次二分查找   （区间第k大 ，主席树...
线段树题集
帅比王的博客
10-07 1650
区间和 题意简述 给定一数列，规定有两种操作，一是修改某个元素，二是求区间的连续和。 解题思路 线段树单点修改，区间查询的模板。 代码示例 #include<bits/stdc++.h> using namespace std; const int N = 1e5+10; typedef long long ll; struct SegmentTree{ int l,r; ll d...
线段树详解：数据结构与算法应用
讲义中给出了一些基础练习题，以帮助巩固对线段树的理解。例如，题目要求对数列进行操作，如连续段的加法、赋值、区间乘积的和以及相邻两数乘积的和等。这些题目展示了线段树在处理不同类型问题时的灵活性。 此外，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值