P4117 [Ynoi2018] 五彩斑斓的世界

最新推荐文章于 2024-10-16 15:56:33 发布
最新推荐文章于 2024-10-16 15:56:33 发布
阅读量306 收藏 5
点赞数 3
分类专栏： ynoi_ds题 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lanthamum/article/details/137458536
版权

分析第一个操作

朴素的做法，遍历一遍大于x就-=x，极限复杂度O(mn)

分块做法

整块:我们维护一个最大值，从mx到x遍历一遍（减去x)用并查集操作merge(i,i-x),考虑mx=100001,x=1,极限复杂度O(mV)

我们可以分析

1.x>(mx/2),从mx到x遍历一遍,应该是最优的复杂度O(mx-x)

2.x<(mx/2),最优的复杂度应该是O(x),因此思考在这种情况下如何操作使得复杂度为O(x)，从x到0遍历一遍呗，我们可以遍历一遍x到0,merge(i,i+x),打上区间减法标记

3.x==(mx/2)都行

通过势能分析法总复杂度应该是O(sqrt(n)V) （我母鸡）（操作让区间最大值和区间最小值的差值变小,，值域缩小）

考虑每次都是x==(mx/2),且mx==V,O(V/2*sqrt(m))?

散块:暴力操作，再重构，无脑真不错，每次最多重构O(2*sqrt(n)),总共O(m*sqrt(n))

分析第二个操作

整块:直接得到并查集的大小

散块:遍历l到r,查询并查集==x,res++;

分析总时间复杂度O(Vsqrt(n)+msqrt(n)),快O(1e9),卡卡常啦

如果这样操作我们应该需要一个O(V*sqrt(n))数组，开不下这么大的数组;

lxl这个trick很妙啊

因为我们块与块之间没有关系，且时间挺多，可以离线下来，答案还有可加性，所以我们可以计算每个块的贡献这样只要开O(V)的数组即可

因此空间复杂度是O(V)，1e6随便开

接下来，我们用代码实现一下。。。

先分析一下我们定义哪些数据 

fa[N]并查集，index[V](存储该值的位置)，val[N](存储该位置的值)，num[V](存储该值的数量),lazy(减法懒标记)，mx(最大值),ans[M](询问的答案）

int a[N];
int fa[N],index[V],num[V],val[N];//fa，该值的位置，大小，该位置的值
int L[B],R[B];//记录每个块的范围[l,r]
int ans[M];
int mx=-INF;
int lazy;//减法懒标记

L,R(设为全局变量也行)

并查集2个操作

1.find

inline int find(int x){
    if(fa[x]==x){
        return x;
    }
    return fa[x]=find(fa[x]);
}

2.merge

合并2个值的位置，2个值的数量，以及合并后要对原数组清空

inline void merge(int x,int y){
    if(index[y]){//值存在
        fa[index[x]]=index[y];//合并
    }else{//不存在
        index[y]=index[x];
        val[index[x]]=y;//赋值为y
    }
    num[y]+=num[x];//合并
    index[x]=0;//清空
    num[x]=0;//清空
}

重构

重新维护一遍之前的量

inline void rebuild(int pos){//记录最大值,合并值,处理值的数量 
    mx=-INF;
    lazy=0;
    for(int i=L[pos];i<=R[pos];i++){
        mx=max(mx,a[i]);
        if(!index[a[i]]){
            index[a[i]]=i;
            fa[i]=i;
            val[i]=a[i];
        }else{
            fa[i]=index[a[i]];
        }
        num[a[i]]++;
    }
}

操作一

1.整块

inline void modify(int x){//区间 O(V)
    if((x<<1)<=(mx-lazy)){//x*2<=mx,
        for(int i=lazy;i<=x+lazy;i++){//a[i]<=x 都加x,lazy+x;O(x);
            if(index[i]){
                merge(i,i+x);
            }
        }
        lazy+=x;
    }else{//2*x>mx
        for(int i=mx;i>x+lazy;i--){//a[i]>x 减去x,O(mx-x);
            if(index[i]){
                merge(i,i-x);
            }
        }
        //最大的值可能有x,与原本的mx取小
        mx=min(mx,x+lazy);
    }
}

min解释一下(我一开始不会)，现在的情况是2*x>mx,可以转化成x>mx-x

分析2种情况

1.mx>x && x(数组中存在x),x

2.mx<x,mx

因此要取min

2.散块

我们要只需要下传懒标记，操作完重构一下即可

inline void update(int l,int r,int x,int pos){
    //下传lazy
    for(int i=L[pos];i<=R[pos];i++){
        int temp=val[find(i)];
        a[i]=temp-lazy;
        index[temp]=0;
        num[temp]=0;
    }
    for(int i=L[pos];i<=R[pos];i++){
        val[i]=0;
    }
    l=max(l,L[pos]);
    r=min(r,R[pos]);
    //暴力操作
    for(int i=l;i<=r;i++){
        if(a[i]>x){ 
            a[i]-=x;
        }
    }
    rebuild(pos);
}

操作二

1.整块

直接加num[]

ans[j]+=num[que[j].x+lazy];

2.遍历一遍

inline int query(int l,int r,int x,int pos){
    int res=0;
    l=max(l,L[pos]);
    r=min(r,R[pos]);
    for(int i=l;i<=r;i++){
        if(val[find(i)]-lazy==x){
            res++;
        }
    }
    return res;
}

感觉询问比较轻松，主要是操作维护这块是难点

完整代码

#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<vector>
#define INF 2147483647
using namespace std;
typedef long long ll;
const int N=1e6+9;
const int B=1e4+9;
const int V=1e5+9;
const int M=5e5+9;
namespace Lan {
    inline string sread() {
        string s=" ";char e=getchar();
        while(e==' '||e=='\n')e=getchar();
        while(e!=' '&&e!='\n')s+=e,e=getchar();
        return s;
    }
    inline void swrite(string s){
        for(char e:s)putchar(e);
        printf("\n");
    }
    inline ll read() {
        ll x=0,y=1;char c=getchar();
        while(!isdigit(c)){if(c=='-')y=-1;c=getchar();}
        while(isdigit(c)){x=(x<<3)+(x<<1)+(c^48);c=getchar();}
        return x*=y;
    }
    inline void write(ll x) {
        if(x<0){x=-x,putchar('-');}ll sta[35],top=0;
        do sta[top++]=x%10,x/=10;while(x);
        while(top)putchar(sta[--top]+'0');
    }
    inline int max(int a,int b){
        if(a>b){
            return a;
        }
        return b;
    }
    inline int min(int a,int b){
        if(a>b){
            return b;
        }
        return a;
    }
}using namespace Lan;
int a[N];
int fa[N],index[V],num[V],val[N];//fa，该值的位置，大小，该位置的值
int L[B],R[B];//记录每个块的范围[l,r]
int ans[M];
int mx=-INF;
int lazy;//减法懒标记
struct Q{
    int op,l,r,x;
}que[M];
inline int find(int x){
    if(fa[x]==x){
        return x;
    }
    return fa[x]=find(fa[x]);
}
inline void merge(int x,int y){
    if(index[y]){//值存在
        fa[index[x]]=index[y];//合并
    }else{//不存在
        index[y]=index[x];
        val[index[x]]=y;//赋值为y
    }
    num[y]+=num[x];//合并
    index[x]=0;//清空
    num[x]=0;//清空
}
inline void rebuild(int pos){//记录最大值,合并值,处理值的数量 
    mx=-INF;
    lazy=0;
    for(int i=L[pos];i<=R[pos];i++){
        mx=max(mx,a[i]);
        if(!index[a[i]]){
            index[a[i]]=i;
            fa[i]=i;
            val[i]=a[i];
        }else{
            fa[i]=index[a[i]];
        }
        num[a[i]]++;
    }
}
inline void modify(int x){//区间 O(V)
    if((x<<1)<=(mx-lazy)){//x*2<=mx,
        for(int i=lazy;i<=x+lazy;i++){//a[i]<=x 都加x,lazy+x;O(x);
            if(index[i]){
                merge(i,i+x);
            }
        }
        lazy+=x;
    }else{//2*x>mx
        for(int i=mx;i>x+lazy;i--){//a[i]>x 减去x,O(mx-x);
            if(index[i]){
                merge(i,i-x);
            }
        }
        //最大的值可能有x,与原本的mx取小
        mx=min(mx,x+lazy);
    }
}
inline int query(int l,int r,int x,int pos){
    int res=0;
    l=max(l,L[pos]);
    r=min(r,R[pos]);
    for(int i=l;i<=r;i++){
        if(val[find(i)]-lazy==x){
            res++;
        }
    }
    return res;
}
inline void update(int l,int r,int x,int pos){
    //下传lazy
    for(int i=L[pos];i<=R[pos];i++){
        int temp=val[find(i)];
        a[i]=temp-lazy;
        index[temp]=0;
        num[temp]=0;
    }
    for(int i=L[pos];i<=R[pos];i++){
        val[i]=0;
    }
    l=max(l,L[pos]);
    r=min(r,R[pos]);
    //暴力操作
    for(int i=l;i<=r;i++){
        if(a[i]>x){ 
            a[i]-=x;
        }
    }
    rebuild(pos);
}
inline void init(){
    mx=-INF;
    lazy=0;
    memset(num,0,sizeof(num));
    memset(index,0,sizeof(index));
}
inline bool inrange(int L,int R,int l,int r){//[l[L,R]r]
    return L>=l && R<=r;
}
inline bool outofrange(int L,int R,int l,int r){
    return L>r || l>R;
}
int main(){
    // ios::sync_with_stdio(false);
    // cin.tie(0),cout.tie(0);
    int n,m;
    n=read();
    m=read();
    for(int i=1;i<=n;i++){
        a[i]=read();
    }
    for(int i=1;i<=m;i++){
        que[i].op=read();
        que[i].l=read();
        que[i].r=read();
        que[i].x=read();
    }
    int blo=sqrt(n);
    int t=ceil(n*1.0/blo);
    for(int i=1;i<=t;i++){
        L[i]=(i-1)*t+1;
        R[i]=i*t;
    }
    //逐块处理
    for(int i=1;i<=t;i++){
        init();
        rebuild(i);
        for(int j=1;j<=m;j++){
            if(que[j].l>que[j].r){
                continue;
            }
            if(outofrange(L[i],R[i],que[j].l,que[j].r)){//不在这个区间
                continue;
            }
            if(que[j].op==1){
                if(inrange(L[i],R[i],que[j].l,que[j].r)){//询问区间包含这个块
                    modify(que[j].x);//整块处理
                }else{
                    update(que[j].l,que[j].r,que[j].x,i);//这一块处理完重构
                }
            }else{
                if(que[j].x+lazy>1e5+1){//没有贡献 
                    continue;
                }
                if(inrange(L[i],R[i],que[j].l,que[j].r)){//询问区间包含这一块
                    ans[j]+=num[que[j].x+lazy];
                }else{
                    ans[j]+=query(que[j].l,que[j].r,que[j].x,i);//只能处理这一块的
                }
            }
        }
    }
    for(int i=1;i<=m;i++){
        if(que[i].op==2){
            write(ans[i]);
            putchar('\n');
        }
    }
    return 0;
}

不愧是大分块，lxl orz，还是刷刷简单点的分块题再来挑战ynoi吧

无期稿件P4119 [Ynoi2018] 未来日记

Lanthanmum
关注
专栏目录
题解 P4117 【[Ynoi2018]五彩斑斓的世界】
09-12 479
题目链接 我觉得AVX2指令集不够爽,于是写了AVX512.到官网查了一天手册，直接拿下最优解 Solution [Ynoi2018]五彩斑斓的世界 题目大意:给定一个长度为\(n\)的序列.每次将\([l,r]\)内大于\(x\)的数减\(x\).询问\([l,r]\)内\(x\)出现了多少次 分析:还能有啥分析,直接暴力,指令集优化一下就可以了 所有函数都可以在Intel手册查到 首...
[Ynoi2018]五彩斑斓的世界
StaroForgin的博客
08-18 399
「突刺贯穿第二分块」，这名字也太中二了吧
luogu P4117 [Ynoi2018] 五彩斑斓的世界
lahlah的博客
08-26 232
https://www.luogu.com.cn/problem/P4117 因为题目的值域只有10510^5105，并且只有减法一种操作，所以我们可以考虑均摊 把所有的减法改成加法 首先还是要分块，维护它的最大值mxmxmx,如果当前修改xxx 2x>=mx2x>=mx2x>=mx,就把所有>x>x>x的全部减去xxx 否则就把所有<=x<=x<=x的加上xxx再把整个块−x-x−x 那么这个时间复杂度是多少呢？ 考虑第一种情况，相当于是用O(mx
洛谷P4117 [Ynoi2018]五彩斑斓的世界 [分块，并查集]
dfn8726的博客
02-17 198
洛谷 Codeforces 又是一道卡常题…… 思路 YNOI当然要分块啦。 分块之后怎么办？ 零散块暴力，整块怎么办？ 显然不能暴力改/查询所有的。考虑把相同值的用并查集连在一起，这样修改时就只需要枚举值了。 然而每次修改的\(x\)特别小时仍然复杂度爆炸，发现大于\(x\)的减去\(x\)等价于小于等于\(x\)的加上\(x\)，然后整体减去\(x\)。 那么，设一个块的最大值为...
[洛谷P4117][CF896E][Ynoi2018]五彩斑斓的世界
*★,°*:.☆(￣▽￣)/$:*.°★*
02-01 571
【题目大意】 给定一个长度为nnn的序列aaa，有mmm次操作： (1).把区间[l,r][l,r][l,r]中大于vvv的数减去vvv (2).查询区间[l,r][l,r][l,r]中vvv的出现次数 所有输入均在[1,100000][1,100000][1,100000]范围内 【算法分析】 这种神仙题当然是分块 如果只考虑整块操作，那么处于同一块且相同的数，每次要么一起减vvv要么一起...
P4117 [Ynoi2018] 五彩斑斓的世界 题解
m0_68967051的博客
08-28 636
P4117 [Ynoi2018] 五彩斑斓的世界 题解
[Ynoi2018]天降之物
StaroForgin的博客
08-19 221
「 弑尽破净的第四分块」，看来出题人越来越中二了。
bzoj5144 [Ynoi2018]末日时在做什么？有没有空？可以来拯救吗？
热门推荐
yfzcsc的博客
01-23 2万+
这个死宅题面就不吐槽了。。。 2018目标：一定要让nzhtl1477" role="presentation" style="position: relative;">nzhtl1477nzhtl1477nzhtl1477把罚抄打通！ 这题当然是O(nn+nlogn)" role="presentation" style="position: relative;">O(nn−−√+nlogn
[Ynoi2018]未来日记
StaroForgin的博客
08-15 283
所以说卡半天块长不如加一个没啥用的特判。再update上一个「望月悲叹的最初分块」。
二叉树系列 10/11
2301_78191305的博客
10-11 420
在这些路径中，只有红色和绿色的路径是伪回文路径，因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ，绿色路径 [2,1,1] 存在回文排列 [1,2,1]。总共有 3 条从根到叶子的路径：红色路径 [2,3,3] ，绿色路径 [2,1,1] 和路径 [2,3,1]。（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）（一个节点的祖父节点是指该节点的父节点的父节点。」的，当它满足：路径经过的所有节点值的排列中，存在一个回文序列。
在顺序结构和链式结构的线性表上实现顺序检索算法
m0_56332819的博客
10-13 236
在顺序结构和链式结构的线性表上实现顺序检索算法，C语言
力扣10.13
qq_40052678的博客
10-13 374
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
c语言练习题2(字符串和函数的使用)
m0_74859128的博客
10-10 366
回文函数用于判断一个给定的字符串是否为回文。输入是一个字符数组（字符串），输出是一个布尔值，表示该字符串是否为回文。编写一个 C 语言程序，计算两个整数在二进制表示中有多少位不同。2. 比较这两个整数在二进制表示中的每一位（共32位）是否不同。1. 提示用户输入两个整数。3. 统计不同的位的数量。4. 输出不同的位数。
Python 使用 Jarvis 算法或包装的凸包（Convex Hull using Jarvis’ Algorithm or Wrapping）
csdn_aspnet的专栏
10-14 1157
例如，当输入 (0, 3), (0, 0), (0, 1), (3, 0), (3, 3) 时，它产生 (0, 3) (0, 0) (3, 0) (3, 3) 的输出；当输入 (0, 3), (0, 1), (0, 0), (3, 0), (3, 3) 时，输出为 (0, 3) (0, 1) (0, 0) (3, 0) (3, 3)。下一个点被选为在逆时针方向上领先于所有其他点的点，即，如果对于任何其他点 r，我们有“orientation(p, q, r) = 逆时针”，则下一个点是 q。
【鸟类识别系统】Python+卷积神经网络算法+人工智能+深度学习+ResNet50算法+计算机课设项目
子午的博客
10-12 946
鸟类识别系统。本系统采用Python作为主要开发语言，通过使用加利福利亚大学开源的200种鸟类图像作为数据集。使用TensorFlow搭建ResNet50卷积神经网络算法模型，然后进行模型的迭代训练，得到一个识别精度较高的模型，然后在保存为本地的H5格式文件。在使用Django开发Web网页端操作界面，实现用户上传一张鸟类图像，识别其名称。本项目通过人工智能技术实现对鸟类图像的自动识别，满足用户在日常生活中快速、准确地识别鸟类的需求。
【C语言】一维数组应用Fibonacci数列
最新发布
我的我的博客
10-16 183
前两项为1，从第三项开始，每一项为前两项的和。可以知道连续三项的关系：f[i]=f[i-1]+f[i-2]使用数组进行存储，十分方便。可以知道前n项的fibonacci数。
数据结构与算法——Java实现 32.堆
m0_73983707的博客
10-10 433
如果权值大于最末尾元素，则不断上调与其（最末尾元素，不断更新）父元素比较，直到找到小于堆中某元素的值或更新到堆顶元素。每个节点的总高度除以结点所在每一层的高度 *（高度-1）之和。有关，高度从下往上依次相加，交换次数为h-1，总交换次数为。大顶堆每个分支的上一个节点的权值要大于它的孩子节点。小顶堆每个分支的上一个节点的权值要小于它的孩子节点。不断的向堆中添加节点，添加时与堆最末尾元素进行比较。Floyd建堆算法的时间复杂度为O(n)时间复杂度为O(n*logn)（与其左右孩子节点中的。
算法：双指针系列（二）——对撞指针
2301_81454749的博客
10-09 768
分享有趣的题目，算法技巧
P4690 [Ynoi2016] 镜中的昆虫
06-01
TokenType.SYMBOL_LEFT_PAREN) { match(TokenType.SYMBOL_LEFT_PAREN); expression(); match(TokenType.SYMBOL_RIGHT_PAREN); } else { throw new Exception("Syntax error"); ... private void match(TokenType ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值