[NOI2005] 维护数列（平衡树）

最新推荐文章于 2022-03-22 18:08:50 发布
原创 最新推荐文章于 2022-03-22 18:08:50 发布 · 464 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#平衡树 #NOI

这篇博客详细介绍了如何使用平衡树来解决NOI2005竞赛中关于数列的一系列操作，包括插入、删除、修改、翻转、求和及求和最大子列的问题。通过解题思路、基本知识、Splay结构体的解析，展示了如何高效地维护数列并实现相关操作。

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

题目

描述

请写一个程序，要求维护一个数列，支持以下6种操作：（请注意，格式栏中的下划线‘ _ ’表示实际输入文件中的空格）

  1. 插入 INSERT_posi_tot_c1_c2_…_ctot 在当前数列的第posi个数字后插入tot个数字：c1, c2, …, ctot；若在数列首插入，则posi为0
  2. 删除 DELETE_posi_tot 从当前数列的第posi个数字开始连续删除tot个数字
  3. 修改 MAKE-SAME_posi_tot_c 将当前数列的第posi个数字开始的连续tot个数字统一修改为c
  4. 翻转 REVERSE_posi_tot 取出从当前数列的第posi个数字开始的tot个数字，翻转后放入原来的位置
  5. 求和 GET-SUM_posi_tot 计算从当前数列开始的第posi个数字开始的tot个数字的和并输出
  6. 求和最大的子列 MAX-SUM 求出当前数列中和最大的一段子列，并输出最大和

输入格式

输入文件的第 1 行包含两个数 N 和 M，N 表示初始时数列中数的个数，M 表示要进行的操作数目。 第 2 行包含 N 个数字，描述初始时的数列。 以下 M 行，每行一条命令，格式参见问题描述中的表格

输出格式

对于输入数据中的 GET-SUM 和 MAX-SUM 操作，向输出文件依次打印结 果，每个答案（数字）占一行。

输入样例

9 8 2 -6 3 5 1 -5 -3 6 3 
GET-SUM 5 4
MAX-SUM
INSERT 8 3 -5 7 2
DELETE 12 1
MAKE-SAME 3 3 2
REVERSE 3 6
GET-SUM 5 4
MAX-SUM

输出样例

-1
10
1
10

说明

你可以认为在任何时刻，数列中至少有 1 个数。
输入数据一定是正确的，即指定位置的数在数列中一定存在。
50%的数据中，任何时刻数列中最多含有 30 000 个数；
100%的数据中，任何时刻数列中最多含有 500 000 个数。
100%的数据中，任何时刻数列中任何一个数字均在[-1 000, 1 000]内。
100%的数据中，M ≤20 000，插入的数字总数不超过 4 000 000 。

解题思路

平衡树… Splay

基本知识

在Splay中进行区间修改时，假设要改的区间是[l,r][l,r]，我们利用Splay的伸展操作将l−1l−1旋转至根，将r+1r+1旋转至根的右儿子，那么要操作的区间[l,r][l,r]就在根的右儿子的左儿子上了。
为了避免找不到l−1l−1或r+1r+1的尴尬，可以事先在平衡树的首尾各插入一个保护节点，然后把每个对[l,r][l,r]操作改成对[l+1,r+1][l+1,r+1]的操作就行了，好写好调。

Splay结构体

struct Splay{
    int son[2], fa, size;// Basic info.
    int sum, mx, lmx, rmx, val;// Maintained info.
    int cov, rev;// tags
    Splay(){
        son[0] = son[1] = fa = size = 0;
        sum = lmx = rmx = 0, val = mx = -INF;
        cov = -INF, rev = 0;
    }
}tr[N];
  • 基本信息
  • 这道题要维护的信息
    • sum：以该节点为根的子树所包含的区间中所有值的和
    • mx, lmx, rmx：mx是区间中的最大子段和，联想线段树中区间最大子段和的维护，我们也需要lmx和rmx，即从左端点往右走的最大子段和从右端点往左走的最大子段。那么：
      tr[id].mx=max(max(tr[lson].mx,tr[rson].mx),tr[lson].rmx+tr[id].val+tr[rson].lmx);(4)(4)tr[id].mx=max(max(tr[lson].mx,tr[rson].mx),tr[lson].rmx+tr[id].val+tr[rson].lmx);
      tr[id].lmx=max(tr[lson].lmx,tr[lson].sum+tr[id].val+tr[rson].lmx);(5)(5)tr[id].lmx=max(tr[lson].lmx,tr[lson].sum+tr[id].val+tr[rson].lmx);
      tr[id].rmx=max(tr[rson].rmx,tr[rson].sum+tr[id].val+tr[lson].rmx);(6)(6)tr[id].rmx=max(tr[rson].rmx,tr[rson].sum+tr[id].val+tr[lson].rmx);
    • val：该节点的值
  • 标记
    • cov：覆盖标记
    • rev：反转标记
  • 初始化
    • son, fa, size为0，不解释了
    • sum为0，val为-INF（注意数字可以为负，所以用-INF表示未赋值）
    • lmx, rmx为0，mx为-INF：这点十分重要，lmx(rmx)可以一个数都不包含，即为0，但是mx必须包含至少一个数，所以初值设为-INF

分析操作

  • INSERT_posi_tot_c1_c2_…_ctot
    先把c1,c2,...,ctotc1,c2,...,ctot建成一颗Splay，再插入到原Splay中去
    inline void insert(int pos){
        splay(select(pos), 0), splay(select(pos+1), root);
        tr[tr[root].son[1]].son[0] = temp;
        tr[temp].fa = tr[root].son[1];
        pushup(tr[root].son[1]), pushup(root);
    }
  • DELETE_posi_tot
    找到要删除的区间，清空所有信息
    （有关back队列和recycle函数的解释见下面注意事项第一条）
    queue<int> back;
    void recycle(int &x){
        if(tr[x].son[0])    recycle(tr[x].son[0]);
        if(tr[x].son[1])    recycle(tr[x].son[1]);
        tr[x].son[0] = tr[x].son[1] = tr[x].fa = tr[x].size = 0;
        tr[x].sum = tr[x].lmx = tr[x].rmx = 0, tr[x].val = tr[x].mx = -INF;
        tr[x].cov = -INF, tr[x].rev = 0;
        back.push(x), x = 0;
    }
    inline void del(int l, int r){
        splay(select(l-1), 0), splay(select(r+1), root);
        recycle(tr[tr[root].son[1]].son[0]);
        pushup(tr[root].son[1]), pushup(root);
    }
  • MAKE-SAME_posi_tot_c
    找到要修改的区间，打上cov标记，同时维护好节点信息
    inline void makeSame(int l, int r, int val){
        splay(select(l-1), 0), splay(select(r+1), root);
        int t = tr[tr[root].son[1]].son[0];
        tr[t].sum = val * tr[t].size;
        tr[t].mx = max(val, tr[t].sum);
        tr[t].lmx = max(0, tr[t].sum);
        tr[t].rmx = max(0, tr[t].sum);
        tr[t].val = val;
        tr[t].cov = val;
        tr[t].rev = 0;
        pushup(tr[root].son[1]), pushup(root);
    }
  • REVERSE_posi_tot
    找到要翻转的区间，打上rev标记，同时维护好节点信息
    inline void reverse(int l, int r){
        splay(select(l-1), 0), splay(select(r+1), root);
        int t = tr[tr[root].son[1]].son[0];
        swap(tr[t].son[0], tr[t].son[1]);
        swap(tr[t].lmx, tr[t].rmx);
        tr[t].rev ^= 1;
        pushup(tr[root].son[1]), pushup(root);
    }
  • GET-SUM_posi_tot
    找到询问的区间，输出节点的sum值
    inline int getSum(int l, int r){
        splay(select(l-1), 0), splay(select(r+1), root);
        return tr[tr[tr[root].son[1]].son[0]].sum;
    }
  • MAX-SUM
    直接输出根节点的mx值
    printf("%d\n", tr[BST.root].mx);

其他函数

  • pushdown
    inline void pushdown(int id){
        if(!id) return;
        if(tr[id].cov != -INF){
            if(lson){
                tr[lson].sum = tr[id].cov * tr[lson].size;
                tr[lson].mx = max(tr[id].cov, tr[lson].sum);
                tr[lson].lmx = max(0, tr[lson].sum);//注意lmx和rmx最小也就为0
                tr[lson].rmx = max(0, tr[lson].sum);
                tr[lson].val = tr[id].cov;
                tr[lson].cov = tr[id].cov;
                tr[id].rev = 0;
            }
            if(rson){
                tr[rson].sum = tr[id].cov * tr[rson].size;
                tr[rson].mx = max(tr[id].cov, tr[rson].sum);
                tr[rson].lmx = max(0, tr[rson].sum);
                tr[rson].rmx = max(0, tr[rson].sum);
                tr[rson].val = tr[id].cov;
                tr[rson].cov = tr[id].cov;
                tr[id].rev = 0;
            }
            tr[id].cov = -INF;
        }
        if(tr[id].rev){
            if(lson){
                swap(tr[lson].son[0], tr[lson].son[1]);
                swap(tr[lson].lmx, tr[lson].rmx);//注意要翻转lmx和rmx
                tr[lson].rev ^= 1;
            }
            if(rson){
                swap(tr[rson].son[0], tr[rson].son[1]);
                swap(tr[rson].lmx, tr[rson].rmx);
                tr[rson].rev ^= 1;
            }
            tr[id].rev = 0;
        }
    }
  • pushup
    inline void pushup(int id){
        tr[id].size = tr[lson].size + tr[rson].size + 1;
        tr[id].sum = tr[lson].sum + tr[rson].sum + tr[id].val;
        tr[id].mx = max(max(tr[lson].mx, tr[rson].mx), tr[lson].rmx + tr[id].val + tr[rson].lmx);
        tr[id].lmx = max(tr[lson].lmx, tr[lson].sum + tr[id].val + tr[rson].lmx);
        tr[id].rmx = max(tr[rson].rmx, tr[rson].sum + tr[id].val + tr[lson].rmx);
    }
  • build 建树
    对于一个已知数列，如果一个一个插入是O(nlogn)O(nlogn)的，太慢了，可以直接二分着建树
    int build(int x[], int l, int r, int fa){
        if(l > r)   return 0;
        int mid = (l + r) >> 1;
        int t = newNode(x[mid]);
        tr[t].fa = fa;
        tr[t].son[0] = build(x, l, mid - 1, t);
        tr[t].son[1] = build(x, mid + 1, r, t);
        pushup(t);
        return t;
    }
  • newNode 新建节点
    充分利用无用节点（见下面注意事项第一条）
    inline int newNode(int val){
        int now;
        if(!back.empty())   now = back.front(), back.pop();
        else    now = ++cnt;
        tr[now].size = 1, tr[now].sum = tr[now].mx = tr[now].val = val;
        tr[now].lmx = tr[now].rmx = max(0, val);
        return now;
    }
  • rotate, splay, select函数：Splay基本操作，不赘述了

注意事项

  1. 这道题空间只给了64MB，所以要回收无用节点，我们可以用一个队列或者栈存一下回收的节点，每次新建一个节点时，如果队列非空，就取出队首编号作为新节点编号，否则才新开一个编号。这就是上面del函数没有直接删掉而是用了一个recycle函数回收节点的原因。
  2. 维护信息时一定不要漏了！
  3. 不要忘了pushup！

Code

#include<algorithm>
#include<cstdio>
#include<queue>

#define lson tr[id].son[0]
#define rson tr[id].son[1]

using namespace std;

const int INF = 1e9;
const int N = 500005;
int n, m, a[N], posi, tot, temp;
char opt[10];

struct Splay{
    int son[2], fa, size;// Basic info.
    int sum, mx, lmx, rmx, val;// Maintained info.
    int cov, rev;// tags
    Splay(){
        son[0] = son[1] = fa = size = 0;
        sum = lmx = rmx = 0, val = mx = -INF;
        cov = -INF, rev = 0;
    }
}tr[N];

struct OPT_Splay{
    int cnt, root;
    queue<int> back;
    inline int newNode(int val){
        int now;
        if(!back.empty())   now = back.front(), back.pop();
        else    now = ++cnt;
        tr[now].size = 1, tr[now].sum = tr[now].mx = tr[now].val = val;
        tr[now].lmx = tr[now].rmx = max(0, val);
        return now;
    }
    inline void pushup(int id){
        tr[id].size = tr[lson].size + tr[rson].size + 1;
        tr[id].sum = tr[lson].sum + tr[rson].sum + tr[id].val;
        tr[id].mx = max(max(tr[lson].mx, tr[rson].mx), tr[lson].rmx + tr[id].val + tr[rson].lmx);
        tr[id].lmx = max(tr[lson].lmx, tr[lson].sum + tr[id].val + tr[rson].lmx);
        tr[id].rmx = max(tr[rson].rmx, tr[rson].sum + tr[id].val + tr[lson].rmx);
    }
    inline void pushdown(int id){
        if(!id) return;
        if(tr[id].cov != -INF){
            if(lson){
                tr[lson].sum = tr[id].cov * tr[lson].size;
                tr[lson].mx = max(tr[id].cov, tr[lson].sum);
                tr[lson].lmx = max(0, tr[lson].sum);
                tr[lson].rmx = max(0, tr[lson].sum);
                tr[lson].val = tr[id].cov;
                tr[lson].cov = tr[id].cov;
                tr[id].rev = 0;
            }
            if(rson){
                tr[rson].sum = tr[id].cov * tr[rson].size;
                tr[rson].mx = max(tr[id].cov, tr[rson].sum);
                tr[rson].lmx = max(0, tr[rson].sum);
                tr[rson].rmx = max(0, tr[rson].sum);
                tr[rson].val = tr[id].cov;
                tr[rson].cov = tr[id].cov;
                tr[id].rev = 0;
            }
            tr[id].cov = -INF;
        }
        if(tr[id].rev){
            if(lson){
                swap(tr[lson].son[0], tr[lson].son[1]);
                swap(tr[lson].lmx, tr[lson].rmx);
                tr[lson].rev ^= 1;
            }
            if(rson){
                swap(tr[rson].son[0], tr[rson].son[1]);
                swap(tr[rson].lmx, tr[rson].rmx);
                tr[rson].rev ^= 1;
            }
            tr[id].rev = 0;
        }
    }
    inline int which(int x){ return tr[tr[x].fa].son[1] == x;}
    inline void rotate(int x, int kind){
        int y = tr[x].fa, z = tr[y].fa, B = tr[x].son[kind];
        tr[x].son[kind] = y, tr[y].son[!kind] = B, tr[z].son[which(y)] = x;
        tr[x].fa = z, tr[y].fa = x, tr[B].fa = y;
        pushup(y), pushup(x);
    }
    inline void splay(int x, int goal){
        if(x == goal)   return;
        while(tr[x].fa != goal){
            int y = tr[x].fa, z = tr[y].fa;
            pushdown(z), pushdown(y), pushdown(x);
            int dir1 = !which(x), dir2 = !which(y);
            if(z == goal)   rotate(x, dir1);
            else{
                if(dir1 == dir2)    rotate(y, dir2);
                else    rotate(x, dir1);
                rotate(x, dir2);
            }
        }
        if(goal == 0)   root = x;
    }
    int build(int x[], int l, int r, int fa){
        if(l > r)   return 0;
        int mid = (l + r) >> 1;
        int t = newNode(x[mid]);
        tr[t].fa = fa;
        tr[t].son[0] = build(x, l, mid - 1, t);
        tr[t].son[1] = build(x, mid + 1, r, t);
        pushup(t);
        return t;
    }
    inline int select(int k){
        int now = root;
        pushdown(now);
        while(tr[tr[now].son[0]].size + 1 != k){
            if(tr[tr[now].son[0]].size >= k)    now = tr[now].son[0];
            else    k -= tr[tr[now].son[0]].size + 1, now = tr[now].son[1];
            pushdown(now);
        }
        return now;
    }
    inline void insert(int pos){
        splay(select(pos), 0), splay(select(pos+1), root);
        tr[tr[root].son[1]].son[0] = temp;
        tr[temp].fa = tr[root].son[1];
        pushup(tr[root].son[1]), pushup(root);
    }
    void recycle(int &x){
        if(tr[x].son[0])    recycle(tr[x].son[0]);
        if(tr[x].son[1])    recycle(tr[x].son[1]);
        tr[x].son[0] = tr[x].son[1] = tr[x].fa = tr[x].size = 0;
        tr[x].sum = tr[x].lmx = tr[x].rmx = 0, tr[x].val = tr[x].mx = -INF;
        tr[x].cov = -INF, tr[x].rev = 0;
        back.push(x), x = 0;
    }
    inline void del(int l, int r){
        splay(select(l-1), 0), splay(select(r+1), root);
        recycle(tr[tr[root].son[1]].son[0]);
        pushup(tr[root].son[1]), pushup(root);
    }
    inline void makeSame(int l, int r, int val){
        splay(select(l-1), 0), splay(select(r+1), root);
        int t = tr[tr[root].son[1]].son[0];
        tr[t].sum = val * tr[t].size;
        tr[t].mx = max(val, tr[t].sum);
        tr[t].lmx = max(0, tr[t].sum);
        tr[t].rmx = max(0, tr[t].sum);
        tr[t].val = val;
        tr[t].cov = val;
        tr[t].rev = 0;
        pushup(tr[root].son[1]), pushup(root);
    }
    inline void reverse(int l, int r){
        splay(select(l-1), 0), splay(select(r+1), root);
        int t = tr[tr[root].son[1]].son[0];
        swap(tr[t].son[0], tr[t].son[1]);
        swap(tr[t].lmx, tr[t].rmx);
        tr[t].rev ^= 1;
        pushup(tr[root].son[1]), pushup(root);
    }
    inline int getSum(int l, int r){
        splay(select(l-1), 0), splay(select(r+1), root);
        return tr[tr[tr[root].son[1]].son[0]].sum;
    }
}BST;

int main(){
    scanf("%d%d", &n, &m);
    for(int i = 2; i <= n + 1; i++) scanf("%d", &a[i]);
    a[1] = -INF, a[n+2] = -INF;
    BST.root = BST.build(a, 1, n + 2, 0);
    while(m--){
        scanf("%s", opt);
        if(opt[2] != 'X')   scanf("%d%d", &posi, &tot), posi++;
        if(opt[0] == 'I'){
            for(int i = 1; i <= tot; i++)   scanf("%d", &a[i]);
            temp = BST.build(a, 1, tot, 0);
            BST.insert(posi);
        }
        else if(opt[0] == 'D')  BST.del(posi, posi + tot - 1);
        else if(opt[2] == 'K'){
            scanf("%d", &a[0]);
            BST.makeSame(posi, posi + tot - 1, a[0]);
        }
        else if(opt[0] == 'R')  BST.reverse(posi, posi + tot - 1);
        else if(opt[0] == 'G')  printf("%d\n", BST.getSum(posi, posi + tot - 1));
        else if(opt[2] == 'X')  printf("%d\n", tr[BST.root].mx);
    }
    return 0;
}
[NOI2005] 维护数列（Splay）
hipamp的博客
10-11 431
题意 要求维护一个数列，支持以下操作： 其中，插入总数字个数小于 4e64e64e6，每个数在 [−1000,1000][-1000,1000][−1000,1000] 范围，保证每次操作合法。 分析 这道题是一道 SplaySplaySplay 码农题，细节颇多，让我们一个一个操作分析。 插入操作 我们可以先对要插入的这 tottottot 个数建树，得到树根 trttrttrt，再将 trttrttrt 插入原序列。 删除操作 就是普通的删除，将 r+1r+1r+1 旋到根，将 l−1l-1l−1
splay伸展树 指针型 平衡树基本操作 序列维护 详细讲解+总结
anantheparty的博客
12-21 3635
转载请保留本博客源地址：http://blog.youkuaiyun.com/u011327397/article/details/53783700 本来是要去学lct，然后看到要用splay我又不会，就开始看splay了，然后发现splay艹起来特别爽，但是序列操作网上没看到有详讲的，理解的时候很多奇怪的问题（无限RE）再加上指针调试复杂度高，花了很多时间，就觉得来写一个讲解吧。
[NOI2005]维护数列
a6t2007的博客
09-08 136
一道splay综合大板子题。 题面：https://www.lydsy.com/JudgeOnline/problem.php?id=1500 下面是题解： 首先对每个点维护这些量： 1.两个儿子（ch[2]） 2.父节点（fa） 3.当前点权值（vl）和子树权值（sum） 4.修改标记（xg），反转标记（fz）。 5.mx，mxl，mxr（不清楚的建议做小白逛公园）。 ...
[NOI2005] 维护数列
still_foolish的博客
11-25 1249
[NOI2005] 维护数列时间限制：3 s 内存限制：256 MB 【问题描述】 请写一个程序，要求维护一个数列，支持以下 6 种操作：（请注意，格式栏中的下划线‘_’表示实际输入文件中的空格） 操作编号 输入文件中的格式 说明1.插入 INSERT_posi_tot_c1_c2_…_ctot 在当前数列的第 posi 个数字后插入 tot个数字：c1, c2, …, ctot；
洛谷P2042 [NOI2005] 维护数列怎么用分块做
最新发布
03-15
不过，题目是NOI2005的，可能比较复杂，因为维护数列通常涉及插入、删除、区间修改、翻转、求和、最大子段和等操作。分块处理这些操作可能比较麻烦，尤其是动态的插入和删除，会导致块的大小变化，影响效率。 首先...
NOI2005官方数据与维修数列解析
在算法竞赛中，数列维护问题经常涉及到数组或序列的更新、查询等操作，常见解决方法包括线段树、树状数组、平衡二叉搜索树（如AVL树或红黑树）、Fenwick树等高级数据结构。这类问题的解决往往需要较高的算法知识和...
运用伸展树解决数列维护问题 by Crash
06-14
实例分析部分提到了NOI 2005的题目“维护数列（Sequence）”，该题涉及在一个数列中频繁进行修改和查询操作。使用伸展树可以有效地解决这类问题，尽管伸展树在区间修改和查询方面比线段树稍显复杂，但它在某些特殊...
伸展树：高效解决数列维护问题
文档中提到的实例分析NOI2005维护数列问题，通过伸展树可以实现快速的插入、删除和查询，同时减少不必要的计算。 对比线段树，伸展树在某些特定情况下可能具有更好的性能，尤其是在访问模式有明显热点时。然而，...
【平衡树】[NOI2005]维修数列
weixin_30412013的博客
01-13 132
Description 请写一个程序，要求维护一个数列，支持以下 6 种操作： 请注意，格式栏 中的下划线‘ _ ’表示实际输入文件中的空格 Input 输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目。 第2行包含N个数字，描述初始时的数列。 以下M行，每行一条命令，格式参见问题描述中的表格。 任何时刻数列中最多含有5...
【平衡树】【NOI 2005】维护数列
morestep的专栏
07-27 1012
339. [NOI2005] 维护数列★★★★☆ 输入文件：seq2005.in 输出文件：seq2005.out 简单对比 时间限制：3 s 内存限制：256 MB 【问题描述】请写一个程序，要求维护一个数列，支持以下 6 种操作：（请注意，格式栏 中的下划线‘ _ ’表示实际输入文件中的空格） 【输入格式】输入文件的第 1 行包含两个数 N 和 M，N 表示初始时数列中数的个数
洛谷 P2042 [NOI2005]维护数列（平衡树）
whisperlzw的博客
04-05 415
题目描述 请写一个程序，要求维护一个数列，支持以下 6 种操作：（请注意，格式栏 中的下划线‘ _ ’表示实际输入文件中的空格） 输入输出格式 输入格式： 输入文件的第 1 行包含两个数 N 和 M，N 表示初始时数列中数的个数，M 表示要进行的操作数目。 第 2 行包含 N 个数字，描述初始时的数列。 以下 M 行，每行一条命令，格式参见问题描述中的表格 输出格式： ...
[NOI2005]维护数列_Splay
EM LGH
09-19 293
这是一道大数据结构题，7月初调了一整天没调出来。昨天突然心血来潮花了一个中午和一个晚自习终于AC了这道大模板题。 其实这道大模拟没有太多思路可言，一定要注意在回收内存时是否将节点信息重置。 即不仅要清空 fif_{i}fi​ , 还要顺便清空该节点所维护的所有信息，如：sumvsumvsumv , maxvmaxvmaxv 等 Code： #include&amp;amp;lt;stack&amp;amp;gt; #includ...
【NOI2005】维护数列
Facico的博客
06-28 933
Description　请写一个程序，要求维护一个数列，支持以下6种操作：（请注意，格式栏中的下划线‘ _ ’表示实际输入文件中的空格） 　　1. 插入 INSERT_posi_tot_c1_c2_…_ctot 在当前数列的第posi个数字后插入tot个数字：c1, c2, …, ctot；若在数列首插入，则posi为0 　　2. 删除 DELETE_posi_tot 从当前数列的第posi个数
维护数列(Splay 平衡树)
xingchenyu1的博客
03-22 287
传送门 维护数列 时间限制：1秒内存限制：128M 题目描述 请写一个程序，要求维护一个数列，支持以下6种操作： 编号 名称 格式 说明 1 插入 INSERT posi tot c ； 在当前数列的第posi个数字后插入tot个数字：c1,c2.....ctot；若在数列首插入，则 posi为 0 2 删除 DELETE posi tot 从当前数列的第posi 个数字开始连续删除tot 个数字 3 修改 MAKE-SAME posi tot c 从当前数列的第 posi个数字...
【noi2005】维护数列
Evil.livE
08-30 3018
      哎呀，不早了，这道题从9点调到了11：30，总之这道题和之前的【poj3580】非常相似，很欣慰的是这次编写的时候思维非常连贯，一口气写完，debug了2个小时发现一直是读入萎了~~，不知道我的数据是不是noi官网的，总之有些点和题目描述的不一样，比如说GET-MAX操作后面诡异的给我来了几个空格，我就一直在201和215之间徘徊。      依然是裸的splay，发现这次的时间有一些惊险，某个点我要8S才跑得出来，（ms时限有10S），开了release以后神速！每个点都不超过2S，很奇怪啊。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值