BZOJ1500维修数列 splay

最新推荐文章于 2018-12-05 18:47:15 发布
最新推荐文章于 2018-12-05 18:47:15 发布
阅读量183 收藏
点赞数 2

一道题昨天写了一天然后写的乱七八糟，后来发现自己思路有问题。然后找了两位大佬的题解：

https://www.cnblogs.com/zig-zag/archive/2013/03/28/2987390.html

http://blog.csdn.net/qwsin/article/details/53995984

侵删。

思路：

splay也可以看作会旋转的线段树。每个结点有 size,sum,maxsum,la,ra（以该节点为根节点的树的节点个数，和，最大连续和，最大前缀和，最大后缀和）,和两个标记cov,rev（覆盖标记和反转标记）。

当对一段区间[l,r]进行区间操作时，先把r+1结点splay到根结点，再把l-1结点 splay到根节点的左儿子，则根节点左儿子的右儿子便是目标区间。

这个题需要使用内存池，不然会TLE；

数组版内存池：开一个栈q，在删除结点x的时候，把结点x放入栈q中。需要建立新结点时，如果q中有可用的结点，则用q中的结点，q为空再新建结点。

指针版内存池：开始时开一个数组Node* pool[maxn]；初始化时将pool全部分配内存。新建结点时从pool里取。

inline void init(){for(int i=0;i<maxn;++i)pool[i]=new Node(0);}
inline void newnode(Node* &p,int v,Node *fa){
    p=pool[top++];*p=Node(v);p->fa=fa;
}
inline void del(Node* &p){pool[--top]=p;p=NULL;}

re的代码还没找到错误···  对拍也一直没错，莫非是递归的splay爆栈了？

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <cstdlib>
using namespace std;
const int maxn=1000000+10;
const int INF=(1<<30);
int a[maxn];
int n,m;
struct Node{
    Node* ch[2];
    int v,s;
    int sum,Msum,ls,rs;
    int re,co;//反转标记和覆盖标记
    Node(int v):v(v){
        s=1;
        ch[0]=ch[1]=NULL;
        re=0;co=INF;
        ls=rs=Msum=sum=v;
    }
    int cmp(int k){
        int d=k;
        if(ch[0]!=NULL)
            d=k-ch[0]->s;
        if(d==1)return -1;
        return d<=0?0:1;
    }
    void maintain(){
        int ll=-INF,rl=-INF,lr=-INF,rr=-INF,lsum=0,rsum=0;//rl右边的l
        int LMsum=-INF,RMsum=-INF;
        s=1;sum=v;
        if(ch[0]!=NULL){
                s+=ch[0]->s;
                lsum=ch[0]->sum;
                ll=ch[0]->ls;
                lr=ch[0]->rs;
                LMsum=ch[0]->Msum;
        }
        if(ch[1]!=NULL){
                s+=ch[1]->s;
                rsum=ch[1]->sum;
                rl=ch[1]->ls;
                rr=ch[1]->rs;
                RMsum=ch[1]->Msum;
        }
        ls=max(ll,lsum+v+max(rl,0));
        rs=max(rr,rsum+v+max(lr,0));
        sum+=lsum+rsum;
        Msum=max(max(LMsum,RMsum),v+max(0,lr)+max(0,rl));
    }
    void pushdown(){//有标记既已经被修改
        if(re){
            if(ch[0]!=NULL){
                    ch[0]->re^=1;
                    swap(ch[0]->ch[0],ch[0]->ch[1]);
                    swap(ch[0]->ls,ch[0]->rs);
            }
            if(ch[1]!=NULL){
                    ch[1]->re^=1;
                    swap(ch[1]->ch[0],ch[1]->ch[1]);
                    swap(ch[1]->ls,ch[1]->rs);
            }
            re=0;
        }
        if(co!=INF){
            if(ch[0]!=NULL){
                ch[0]->co=co;
                ch[0]->v=co;
                ch[0]->sum=ch[0]->s*co;
                ch[0]->ls=ch[0]->rs=ch[0]->Msum=max(co,ch[0]->sum);
            }
            if(ch[1]!=NULL){
                ch[1]->co=co;
                ch[1]->v=co;
                ch[1]->sum=ch[1]->s*co;
                ch[1]->ls=ch[1]->rs=ch[1]->Msum=max(co,ch[1]->sum);
            }
            co=INF;
        }
    }
}*pool[maxn],*root;
int top;
void init(){
    top=0;
    for(int i=0;i<=maxn;i++)pool[i]=new Node(0);
}
Node* newnode(int v){
    Node* o=pool[top++];
    *o=Node(v);
    return o;
}
void del(Node* &o){pool[--top]=o;o=NULL;}
void deltree(Node* &o){//将o和其子树删除
    if(o->ch[0]!=NULL)deltree(o->ch[0]);
    if(o->ch[1]!=NULL)deltree(o->ch[1]);
    del(o);
}
void rotate(Node* &o,int d){
    Node* k=o->ch[d^1];o->ch[d^1]=k->ch[d];k->ch[d]=o;
    o->maintain();k->maintain();o=k;
}
void splay(Node* &o,int k){//将第k大的结点转到o的位置
    o->pushdown();
    int d=o->cmp(k);
    if(d==1)
        if(o->ch[0]!=NULL)
            k-=o->ch[0]->s+1;
        else k=k-1;
    if(d!=-1){
        Node* p=o->ch[d];
        p->pushdown();
        int d2=p->cmp(k);
        int k2;
        if(d2==1){
            if(p->ch[0]!=NULL)
                k2=k-p->ch[0]->s-1;
            else k2=k-1;
        }else k2=k;
        if(d2!=-1){
            splay(p->ch[d2],k2);
            if(d==d2)rotate(o,d^1);else rotate(o->ch[d],d);
        }
        rotate(o,d^1);
    }
}
void split(Node* o,Node* &left,Node* &right,int k){
    splay(o,k);
    o->pushdown();
    right=o->ch[1];
    left=o;
    left->ch[1]=NULL;
    left->maintain();
}
Node* merge(Node* left,Node* right){
    if(left->ch[1]!=NULL)
    splay(left,left->s);
    left->pushdown();
    left->ch[1]=right;
    left->maintain();
    return left;
}
Node* build(int l,int r){
    if(l>r)return NULL;
    int mid=l+(r-l)/2;
    //Node* o=new Node(a[mid]);

    Node*o=newnode(a[mid]);
    o->ch[0]=build(l,mid-1);
    o->ch[1]=build(mid+1,r);
    o->maintain();
}
void tra(Node* o){
    o->pushdown();
    if(o->ch[0]!=NULL)tra(o->ch[0]);
    cout<<o->v<<" "<<o->s<<" "<<o->sum<<" "<<o->Msum<<endl;
    if(o->ch[1]!=NULL)tra(o->ch[1]);
}
void insert(Node* &o){
    int pos,tot;
    scanf("%d%d",&pos,&tot);
    for(int i=1;i<=tot;i++)
        scanf("%d",&a[i]);
    Node* mid=build(1,tot);
    Node* left,*right;
    split(o,left,right,pos+1);
    o=merge(merge(left,mid),right);
}
void remove(Node* &o){
    int pos,tot;
    scanf("%d%d",&pos,&tot);
    Node* left,*mid,*right;
    split(o,left,mid,pos);
    split(mid,mid,right,tot);
   // delete mid;
    deltree(mid);
    o=merge(left,right);
}
void recover(Node* &o){
    int pos,tot,c;
    scanf("%d%d%d",&pos,&tot,&c);
    Node* left,*mid,*right;
    split(o,left,mid,pos);
    split(mid,mid,right,tot);
    mid->co=c;mid->v=c;
    mid->ls=mid->rs=mid->sum=c*mid->s;
    mid->Msum=max(mid->sum,c);
    //mid->pushdown();
    o=merge(merge(left,mid),right);
}
void reverse(Node* &o){
    int pos,tot;
    scanf("%d%d",&pos,&tot);
    Node* left,*mid,*right;
    split(o,left,mid,pos);
    split(mid,mid,right,tot);
    mid->re^=1;
    swap(mid->ch[0],mid->ch[1]);
    swap(mid->ls,mid->rs);
    o=merge(merge(left,mid),right);
}
int sum(Node* &o){
    int pos,tot,ans;
    scanf("%d%d",&pos,&tot);
    Node* left,*mid,*right;
    split(o,left,mid,pos);
    split(mid,mid,right,tot);
    ans= mid->sum;
    o=merge(merge(left,mid),right);
    return ans;
}
int MAXSUM(Node* &o){
    Node* left,*right;
    split(o,left,right,1);
    int ans=right->Msum;
    o=merge(left,right);
    return ans;
}
int main(){
    init();
    scanf("%d%d",&n,&m);
    for(int i=2;i<=n+1;i++)scanf("%d",&a[i]);
    a[1]=0;
    root=build(1,n+1);
    string name;
    for(int i=1;i<=m;i++){
        cin>>name;
        if(name=="INSERT"){
            insert(root);
        }
        if(name=="DELETE"){
            remove(root);
        }
        if(name=="MAKE-SAME"){
            recover(root);
        }
        if(name=="REVERSE"){
            reverse(root);
        }
        if(name=="GET-SUM"){
            cout<<sum(root)<<endl;
        }
        if(name=="MAX-SUM"){
            cout<<MAXSUM(root)<<endl;
        }
    }
return 0;
}

 




liuqvanlu
关注
BZOJ1500 维修数列 splay
binarycopycode
01-26 173
orz hzwer... lx[x]表示x的子树的中序遍历的最左节点开始向右的最大和，可以在任意地方结束,rx[x]表示x这棵子树的中序遍历最右节点开始向左的最大和。mx[x]是这棵子树的最大值，这样就很好维护了。 tag[x]是这棵子树被全部赋值的标记，rev[x]是这棵子树被反转的标记 #include&lt;cstdio&gt; #include&lt;cstring&gt; #in...
bzoj1500维修数列splay
maxtir的博客
08-25 333
1500: [NOI2005]维修数列 Time Limit: 10 Sec  Memory Limit: 64 MB Submit: 14759  Solved: 4832 [Submit][Status][Discuss] Description Input 输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目
BZOJ1500维修数列Splay
Sakai_Masato的博客
02-02 405
不得不说这题目真的猥琐，写一个小时调一晚上加一上午，还被卡常了。 这里不放题解，主要来总结一下Splay区间修改比较猥琐的地方。 一 、查找第k大的时候一定要记得push_down； 二、有改值标记的题目push_down一定要写成改值的push_down，今天我才知道我以前写的线段树都是jg，全是错的标记方式。 三、注意一下边界问题和Splay函数里的push_down和update操
BZOJ 1500 维修数列 Splay
alpc_paul的专栏
08-21 837
SPLAY 模板题  代码： #include #include #include #include #define splay_pool NIL using namespace std; const int max_size=500010; const int INF=(1ll<<31)-2; struct Node { int val,size; Node *lch
bzoj1500 维修数列(splay)
weixin_30237719的博客
09-17 62
小破树splay的终极模板(gou)题，小细节很多 而我tm把容易错的地方基本都错了一遍。。。 随便列出几个我错的细节(太多了列不完都)。。。 　　1.不能找前驱和后继，因为不把标记推完就贸然splay会使标记传乱！ 　　2.Make_same的标记不能记录修改的值，因为如果把某一区间修改成0标记无法下传！ 　　3.下传Reverse标记时不但要转左右儿子，还要转左右最大值！ ...
BZOJ1500 维修数列
weixin_34174422的博客
08-06 83
目录 BZOJ1500　维修数列 题解 ｃｏｄｅ BZOJ1500　维修数列 题目传送门 题解 一道比较全的平衡树题目，操作比较多，注意一下如果不回收节点的话可能会\(MLE\)，手写个内存池就行了 ｃｏｄｅ #include <bits/stdc++.h> using ...
【bzoj1500】维修数列 splay
chty_syq的博客
02-15 313
AC通道：http://www.lydsy.com/JudgeOnline/problem.php?id=1500 【题解】 这是一道很恶心的题，虽然差不多是splay的板子。 我们用mx[x]表示以x为根的子树内最大子串和，lx[x]表示以x为根的子树中以左端点为起点向右延伸的最大子串和，rx[x]表示从右端点向左延伸的最大子串和。 维护rx和lx的过程中要注意单个结点的情况：如果v[x
BZOJ 1500 维修数列
Rayment的博客
03-15 256
Problem BZOJ请戳我 Solution 又是一道splay的恶心题，大模拟(真相了)，细节多。 首先这道题卡空间，而且节点多，你需要开个队列回收被删除的节点，写个get函数。 然后按照套路，你需要两个哨兵节点。 对于插入操作，由于插入节点较多，用insert操作会导致复杂度变成O(nlogn)O(nlogn)O(nlogn)，不如直接直接调用build函数，旋出需要插入的...
BZOJ 1500 维修序列 Splay
INCINCIBLE的博客
02-20 340
题目链接： (http://www.lydsy.com/JudgeOnline/problem.php?id=1500) 各种区间操作，但是方法都是统一的 对于操作区间[L,R] 先把(L-1)旋转到根节点，再把(R+1)旋转到根的右儿子，那么需要操作的区间[L,R]就是根的 右儿子的左儿子。 但是L==1和R==n都需要特判，非常麻烦。所以不妨在前后都加一个数字，变成N+2长度的序列，就
【BZOJ】1500: [NOI2005]维修数列-splay
远行客
12-05 143
splay模板
BZOJ1500: [NOI2005]维修数列（洛谷P2042）
forezxl的博客
12-09 345
Splay
BZOJ 3223 浅谈SPLAY伸展树算法区间翻转
BerryKanry的博客
07-19 1516
世界真的很大 SPLAY是个很厉害的数据结构，相对于其他平衡树，比如treap，对于每一次查询虽然常数偏大，但是却能力保总复杂度趋近于nlogn，而且除了treap能支持的操作以外，还支持如区间翻转一类的特殊操作 其关键在于其独属的SPLAY操作 所以这次更多的是对SPLAY的一个详细总结 好像也是tarjan发明的，orz 看题先： description：您需要写一种数据结构（可参考
区间翻转 bzoj 3223 文艺平衡树 （splay）
w4149
05-26 1925
【bzoj3223】Tyvj 1729 文艺平衡树Description 您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作：翻转一个区间，例如原有序序列是5 4 3 2 1，翻转区间是[2,4]的话，结果是5 2 3 4 1Input 第一行为n,m n表示初始序列有n个数，这个序列依次是(1,2……n-1,n) m表示翻转操作次数 接下来m行每行两个数[l,r
BZOJ 题目整理
喵~
08-31 2296
现在要写一些题目。 现在已经做了：157题
基于yolov3结合卡尔曼滤波匈牙利算法虚拟线圈的车流量检测python源码+项目说明.zip
09-21
本项目专注于视频基的车辆跟踪与流量统计，依托深度学习技术，实时追踪路面车辆动态并精准统计各车道车流量。该项目通过以下核心步骤高效处理输入视频数据： 高精度目标检测：采用YOLOv3模型，凭借其卓越的实时性与准确性，快速识别视频中的车辆目标，为后续追踪奠定坚实基础。 稳定目标追踪：集成SORT（Simple Online and Realtime Tracking）算法，结合卡尔曼滤波器预测车辆未来位置，同时运用匈牙利算法优化目标间的匹配，实现连续、稳定的车辆追踪，有效应对遮挡、交叉等复杂场景。 智能车流量统计：借鉴虚拟线圈概念，巧妙设计算法以监测穿越预设区域的车辆，自动计数并准确统计各车道车流量，为交通管理与分析提供可靠数据支持。 整体而言，本项目通过融合先进的目标检测与追踪技术，结合创新的流量统计方法，构建了一个高效、精准的实时车辆跟踪与流量统计系统，为智慧交通领域的发展贡献力量。
本科毕业设计--基于深度学习的人脸面部表情识别.zip
最新发布
09-21
深度学习是机器学习的一个子领域，它基于人工神经网络的研究，特别是利用多层次的神经网络来进行学习和模式识别。深度学习模型能够学习数据的高层次特征，这些特征对于图像和语音识别、自然语言处理、医学图像分析等应用至关重要。以下是深度学习的一些关键概念和组成部分： 1. **神经网络（Neural Networks）**：深度学习的基础是人工神经网络，它是由多个层组成的网络结构，包括输入层、隐藏层和输出层。每个层由多个神经元组成，神经元之间通过权重连接。 2. **前馈神经网络（Feedforward Neural Networks）**：这是最常见的神经网络类型，信息从输入层流向隐藏层，最终到达输出层。 3. **卷积神经网络（Convolutional Neural Networks, CNNs）**：这种网络特别适合处理具有网格结构的数据，如图像。它们使用卷积层来提取图像的特征。 4. **循环神经网络（Recurrent Neural Networks, RNNs）**：这种网络能够处理序列数据，如时间序列或自然语言，因为它们具有记忆功能，能够捕捉数据中的时间依赖性。 5. **长短期记忆网络（Long Short-Term Memory, LSTM）**：LSTM 是一种特殊的 RNN，它能够学习长期依赖关系，非常适合复杂的序列预测任务。 6. **生成对抗网络（Generative Adversarial Networks, GANs）**：由两个网络组成，一个生成器和一个判别器，它们相互竞争，生成器生成数据，判别器评估数据的真实性。 7. **深度学习框架**：如 TensorFlow、Keras、PyTorch 等，这些框架提供了构建、训练和部署深度学习模型的工具和库。 8. **激活函数（Activation Functions）**：如 ReLU、Sigmoid、Tanh 等，它们在神经网络中用于添加非线性，使得网络能够学习复杂的函数。 9. **损失函数（Loss Functions）**：用于评估模型的预测与真实值之间的差异，常见的损失函数包括均方误差（MSE）、交叉熵（Cross-Entropy）等。 10. **优化算法（Optimization Algorithms）**：如梯度下降（Gradient Descent）、随机梯度下降（SGD）、Adam 等，用于更新网络权重，以最小化损失函数。 11. **正则化（Regularization）**：技术如 Dropout、L1/L2 正则化等，用于防止模型过拟合。 12. **迁移学习（Transfer Learning）**：利用在一个任务上训练好的模型来提高另一个相关任务的性能。 深度学习在许多领域都取得了显著的成就，但它也面临着一些挑战，如对大量数据的依赖、模型的解释性差、计算资源消耗大等。研究人员正在不断探索新的方法来解决这些问题。
雷电模拟器改成真机环境
09-21
在Android系统中，模拟器通常会被识别为非真实的设备，这可能导致某些应用或服务无法正常运行，尤其是那些需要硬件信息或root权限的应用。改真机环境意味着通过技术手段使模拟器的行为更接近真实的Android设备，包括模拟设备硬件信息、IMEI、MAC地址等，以绕过检测并提升兼容性。LSPSED（Linux System Property Setter and Editor）模块是Magisk的一个扩展，专门用于修改Android系统的系统属性。通过LSPSED，我们可以更改设备的各种系统属性，如设备型号、制造商信息等，这些修改对于使模拟器看起来更像真实设备至关重要。在使用过程中，还需要添加几个机型模块，这些模块通常包含了特定设备的系统配置信息，如设备代号、硬件信息等。通过安装这些模块，雷电模拟器可以模仿各种流行的Android设备，进一步提高应用的兼容性和真实性。
CenterNet 部署版本，便于移植不同平台（onnx、tensorRT、rknn、Horizon）
09-21
CenterNet 是一种用于目标检测的神经网络架构，它的核心思想是利用目标的中心点作为检测的关键信息。这种方法与传统的目标检测方法（如基于边界框的方法）有所不同，因为它不直接预测目标的边界框，而是预测目标的中心点坐标和目标的宽度与高度。 CenterNet 的主要特点包括： 1. **中心点预测**：网络输出目标的中心点坐标，以及目标的宽度和高度。 2. **热图（Heatmap）**：网络生成一个热图，其中每个像素点的值表示该点成为目标中心点的概率。 3. **回归任务**：除了中心点坐标，网络还需要预测目标的宽度和高度，这通常通过预测中心点周围的偏移量来实现。 4. **多任务学习**：CenterNet 通常会同时预测目标的类别、中心点坐标、宽度、高度以及目标的旋转角度（在某些变体中）。 5. **端到端训练**：CenterNet 可以直接在最终的目标检测任务上进行端到端的训练，无需复杂的区域提议网络（Region Proposal Network, RPN）或锚点（anchor）机制。 6. **高效性**：由于省略了传统目标检测中的一些步骤，CenterNe
bzoj.org俄罗斯方块
05-06
bzoj.org是一个在线的编程题库，其中包含了很多经典算法问题和实际应用中的编程问题。其中包括了很多有趣的游戏算法问题，比如Puzzle，Tetris等。 而bzoj.org俄罗斯方块就是在该平台上的一个经典的俄罗斯方块游戏。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值