维修数列-平衡树的硬板子

最新推荐文章于 2021-09-24 23:43:10 发布
最新推荐文章于 2021-09-24 23:43:10 发布
阅读量176 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cucuc1/article/details/109561437
版权

题目链接

  题意就是一个简单的平衡树的板子，但是在实现上有很多细节,蒟蒻的我竟然debug了3天，只能说自己的板子不硬，更新下板子
 因为细节挺多的(至少我觉得是，所以就直接以注释的形式写在代码里了)但是要注意，这里说的子列是连续的子列。
 因为看网上的题解说的好像在bzoj上一直开新点会内存超限，为了防止也出现这个情况，我特意学了一手节点回收分配(虽然最后也没啥用好像)

超长代码(捂脸)

#include <bits/stdc++.h>
#define ss system("pause");

using namespace std;

const int maxn = 500000;
const int INF = 1e9;

/********************
splay树
********************/

struct  node
{
	int f,val,size,ch[2],cnt;
    int sum,lmax,rmax,maxsum;
    bool rev,tag;
	node() {}
	node(int v){
		f = ch[0] = ch[1] = rev = tag = 0;
		size = cnt = 1;
		val = sum = lmax = rmax = maxsum = v;
	}
}tree[maxn];

int root,sz,top;
int org[maxn],sta[maxn];

inline void splay(int x,int goal);
int findkth(int x);

//节点分配回收机制
inline int new_node()
{
	return top?sta[top--]:++sz;
}

inline void update(int x)
{
	//对0节点进行初始赋值的原因就在于防止0节点影响对于有负值节点的更新
	//会造成负数值的更新出现问题
	int lc = tree[x].ch[0],rc = tree[x].ch[1];
	tree[x].size = tree[lc].size + tree[rc].size + 1;
    tree[x].sum = tree[lc].sum + tree[rc].sum + tree[x].val;
	tree[x].maxsum = max(max(tree[lc].maxsum,tree[rc].maxsum),max(0,tree[lc].rmax) + tree[x].val + max(0,tree[rc].lmax));
    tree[x].lmax = max(tree[lc].lmax,max(0,tree[rc].lmax) + tree[x].val + tree[lc].sum);
    tree[x].rmax = max(tree[rc].rmax,max(0,tree[lc].rmax) + tree[x].val + tree[rc].sum);
}

void Replace(int x,int d)
{
    if(!x) return ;
    tree[x].val = d;
    tree[x].sum = d * tree[x].size;
    tree[x].maxsum = tree[x].lmax = tree[x].rmax = max(d,d * tree[x].size);
    tree[x].rev = 0,tree[x].tag = 1;
}

void Mak(int pos,int tot,int d)//把指定区间全部转化成指定值
{
	int l = pos - 1,r = pos + tot;
	l = findkth(l),r = findkth(r);
	splay(l,0),splay(r,l);
	int u = tree[root].ch[1];
	Replace(tree[u].ch[0],d);
	update(u),update(root);
}

inline void rev(int x)
{
	if(tree[x].tag) return ;
	tree[x].rev ^= 1;
	swap(tree[x].ch[0],tree[x].ch[1]);
	swap(tree[x].lmax,tree[x].rmax);//左右的最大值也会跟着反转
}

inline void pushdown(int x)
{
    if(tree[x].rev){
		if(tree[x].ch[0]) rev(tree[x].ch[0]);
		if(tree[x].ch[1]) rev(tree[x].ch[1]);
        tree[x].rev = 0;
    }
    if(tree[x].tag){
		if(tree[x].ch[0]) Replace(tree[x].ch[0],tree[x].val);
        if(tree[x].ch[1]) Replace(tree[x].ch[1],tree[x].val);
        tree[x].tag = 0;
	}
}

inline void rotate(int x)
{
	int fa = tree[x].f,gfa = tree[fa].f;
	pushdown(x),pushdown(fa), pushdown(gfa);
	//判断x是父节点的哪个儿子，0为左，1为右
	int k = (tree[fa].ch[1] == x);
	//把x的父节点在gfa的位置用x取代
	tree[gfa].ch[tree[gfa].ch[1] == fa] = x;
	tree[x].f = gfa;//x的父亲节点变成了gfa
	tree[fa].ch[k] = tree[x].ch[k^1];
	tree[tree[x].ch[k^1]].f = fa;
	tree[x].ch[k^1] = fa;
	tree[fa].f = x;
	update(fa),update(x);
}

inline void splay(int x,int goal)
{
	//pushdown(x);
	while(tree[x].f != goal){
		int fa = tree[x].f , gfa = tree[fa].f;
		if(gfa != goal){
			((tree[gfa].ch[0] == fa) ^ (tree[fa].ch[0] == x)) ? rotate(x) : rotate(fa);
		}
		rotate(x);
	}
	if(goal == 0) root = x;
}

void build_tree(int &rt,int l, int r, int fa)
{
	int mid = (l + r) >> 1;
	rt = new_node();
	tree[rt] = node(org[mid]);
	tree[rt].f = fa;
	if(l == r) return ;
	if(l < mid) build_tree(tree[rt].ch[0],l, mid - 1,rt);
	if(r > mid) build_tree(tree[rt].ch[1],mid + 1,r, rt);
	update(rt);
}

int findkth(int x)
{
	if(tree[root].size < x) return -1;
	int u = root;
	while(1){
		pushdown(u);
		if(x <= tree[tree[u].ch[0]].size){
			u = tree[u].ch[0];
		}
		else if(x <= tree[tree[u].ch[0]].size + tree[u].cnt){
			return u;
		}
		else{
			x -= (tree[tree[u].ch[0]].size + tree[u].cnt);
			u = tree[u].ch[1];
		}
	}
}

 void Reverse(int x,int tot)
 {
 	int l = x - 1,r = x + tot;
 	l = findkth(l) , r = findkth(r);
 	splay(l,0),splay(r,l);
 	int u = tree[root].ch[1];
 	int pos = tree[u].ch[0];
	if(tree[pos].tag) return ;//如果这个区间已经被标记整体修改了，就没有必要反转了
	rev(pos);
	//这里反转不能像之前一样打标记就可以了
	//因为反转完这个序列的最大左右值肯定会变化
	//所以要直接反转完并进行值的更新,这个标记是指的子节点
	update(u),update(root);
 }

void erase(int x)
{
	if(!x) return ;
	sta[++top] = x;
	erase(tree[x].ch[0]),erase(tree[x].ch[1]);
}

void cut(int a,int tot)
{
	int l = a - 1,r = a + tot;
	l = findkth(l) , r = findkth(r);
	splay(l,0),splay(r,l);
	int u = tree[root].ch[1];
	erase(tree[u].ch[0]),tree[u].ch[0] = 0;
	update(u),update(root);
}

void add(int pos,int tot)
{
    for(int i = 1; i <= tot; i++){
        scanf("%d",org + i);
    }
	//将区间[a,b]后接到c后面
	int l = pos,  r = pos + 1;
	l = findkth(l) , r = findkth(r);
	splay(l,0) , splay(r, l);
	int u = tree[root].ch[1];
    build_tree(tree[u].ch[0],1,tot,u);
	update(u),update(root);
}

//获取区间和
int Get_Sum(int pos,int tot)
{
    int l = pos - 1,r = pos + tot;
    l = findkth(l) , r = findkth(r);
	splay(l,0), splay(r,l);
    int u = tree[root].ch[1];
    return tree[tree[u].ch[0]].sum;
}

void inorder(int rt)
{
	if(!rt) return ;
	pushdown(rt);
	if(tree[rt].ch[0]) inorder(tree[rt].ch[0]);
	cout<<tree[rt].val<<' ';
	if(tree[rt].ch[1]) inorder(tree[rt].ch[1]);
}

int main()
{
	int n,q;
	string s;
	scanf("%d%d",&n,&q);
	for(int i = 1; i <= n; i++) scanf("%d",org + i + 1);
	org[1] = org[n + 2] = -INF;
	//由于不存在的节点标志为0，所以为了防止update时把0节点也错误计算进去，要对0节点进行赋值
	//-INF是为了防止更新区间最大值的时候，把一些节点的负数值判定为0，造成部分的最大值的和会偏大
	tree[0] = node(-INF),tree[0].size = tree[0].sum = 0;
	build_tree(root,1,n + 2,0);		
	while(q--){
		cin>>s;
		if(s == "MAX-SUM") printf("%d\n",tree[root].maxsum);
		else {
			int pos,tot;
			scanf("%d%d",&pos,&tot);
			if(s == "GET-SUM"){
				int ans = Get_Sum(pos + 1,tot);
				printf("%d\n",ans);
			}
			if(s == "INSERT") add(pos + 1,tot);
			if(s == "MAKE-SAME"){
				int d;
				scanf("%d",&d);
				Mak(pos + 1,tot,d);
			}
			if(s == "DELETE") cut(pos + 1,tot);
			if(s == "REVERSE") Reverse(pos + 1,tot);
		}
		//inorder(root);
	    //cout<<endl;
	}
	//ss;
	return 0;
}

再加一个洛谷上相似的例题：
  SP4487 GSS6 - Can you answer these queries VI

只是把区间操作换成了单点

code

#include <bits/stdc++.h>
#define ss system("pause");

using namespace std;

const int maxn = 500000;
const int INF = 1e9;

/********************
splay树
********************/

struct  node
{
	int f,val,size,ch[2],cnt;
    int sum,lmax,rmax,maxsum;
    bool rev,tag;
	node() {}
	node(int v){
		f = ch[0] = ch[1] = rev = tag = 0;
		size = cnt = 1;
		val = sum = lmax = rmax = maxsum = v;
	}
}tree[maxn];

int root,sz,top;
int org[maxn],sta[maxn];

inline void splay(int x,int goal);
int findkth(int x);

//节点分配回收机制
inline int new_node()
{
	return top?sta[top--]:++sz;
}

inline void update(int x)
{
	//对0节点进行初始赋值的原因就在于防止0节点影响对于有负值节点的更新
	//会造成负数值的更新出现问题
	int lc = tree[x].ch[0],rc = tree[x].ch[1];
	tree[x].size = tree[lc].size + tree[rc].size + 1;
    tree[x].sum = tree[lc].sum + tree[rc].sum + tree[x].val;
	tree[x].maxsum = max(max(tree[lc].maxsum,tree[rc].maxsum),max(0,tree[lc].rmax) + tree[x].val + max(0,tree[rc].lmax));
    tree[x].lmax = max(tree[lc].lmax,max(0,tree[rc].lmax) + tree[x].val + tree[lc].sum);
    tree[x].rmax = max(tree[rc].rmax,max(0,tree[lc].rmax) + tree[x].val + tree[rc].sum);
}

void Replace(int x,int d)
{
    if(!x) return ;
    tree[x].val = d;
    tree[x].sum = d * tree[x].size;
    tree[x].maxsum = tree[x].lmax = tree[x].rmax = max(d,d * tree[x].size);
    tree[x].rev = 0,tree[x].tag = 1;
}

void Mak(int pos,int tot,int d)//把指定区间全部转化成指定值
{
	int l = pos - 1,r = pos + tot;
	l = findkth(l),r = findkth(r);
	splay(l,0),splay(r,l);
	int u = tree[root].ch[1];
	Replace(tree[u].ch[0],d);
	update(u),update(root);
}

inline void rev(int x)
{
	if(tree[x].tag) return ;
	tree[x].rev ^= 1;
	swap(tree[x].ch[0],tree[x].ch[1]);
	swap(tree[x].lmax,tree[x].rmax);//左右的最大值也会跟着反转
}

inline void pushdown(int x)
{
    if(tree[x].rev){
		if(tree[x].ch[0]) rev(tree[x].ch[0]);
		if(tree[x].ch[1]) rev(tree[x].ch[1]);
        tree[x].rev = 0;
    }
    if(tree[x].tag){
		if(tree[x].ch[0]) Replace(tree[x].ch[0],tree[x].val);
        if(tree[x].ch[1]) Replace(tree[x].ch[1],tree[x].val);
        tree[x].tag = 0;
	}
}

inline void rotate(int x)
{
	int fa = tree[x].f,gfa = tree[fa].f;
	pushdown(x),pushdown(fa), pushdown(gfa);
	//判断x是父节点的哪个儿子，0为左，1为右
	int k = (tree[fa].ch[1] == x);
	//把x的父节点在gfa的位置用x取代
	tree[gfa].ch[tree[gfa].ch[1] == fa] = x;
	tree[x].f = gfa;//x的父亲节点变成了gfa
	tree[fa].ch[k] = tree[x].ch[k^1];
	tree[tree[x].ch[k^1]].f = fa;
	tree[x].ch[k^1] = fa;
	tree[fa].f = x;
	update(fa),update(x);
}

inline void splay(int x,int goal)
{
	//pushdown(x);
	while(tree[x].f != goal){
		int fa = tree[x].f , gfa = tree[fa].f;
		if(gfa != goal){
			((tree[gfa].ch[0] == fa) ^ (tree[fa].ch[0] == x)) ? rotate(x) : rotate(fa);
		}
		rotate(x);
	}
	if(goal == 0) root = x;
}

void build_tree(int &rt,int l, int r, int fa)
{
	int mid = (l + r) >> 1;
	rt = new_node();
	tree[rt] = node(org[mid]);
	tree[rt].f = fa;
	if(l == r) return ;
	if(l < mid) build_tree(tree[rt].ch[0],l, mid - 1,rt);
	if(r > mid) build_tree(tree[rt].ch[1],mid + 1,r, rt);
	update(rt);
}

int findkth(int x)
{
	if(tree[root].size < x) return -1;
	int u = root;
	while(1){
		pushdown(u);
		if(x <= tree[tree[u].ch[0]].size){
			u = tree[u].ch[0];
		}
		else if(x <= tree[tree[u].ch[0]].size + tree[u].cnt){
			return u;
		}
		else{
			x -= (tree[tree[u].ch[0]].size + tree[u].cnt);
			u = tree[u].ch[1];
		}
	}
}

 void Reverse(int x,int tot)
 {
 	int l = x - 1,r = x + tot;
 	l = findkth(l) , r = findkth(r);
 	splay(l,0),splay(r,l);
 	int u = tree[root].ch[1];
 	int pos = tree[u].ch[0];
	if(tree[pos].tag) return ;//如果这个区间已经被标记整体修改了，就没有必要反转了
	rev(pos);
	//这里反转不能像之前一样打标记就可以了
	//因为反转完这个序列的最大左右值肯定会变化
	//所以要直接反转完并进行值的更新,这个标记是指的子节点
	update(u),update(root);
 }

void erase(int x)
{
	if(!x) return ;
	sta[++top] = x;
	erase(tree[x].ch[0]),erase(tree[x].ch[1]);
}

void cut(int a,int tot)
{
	int l = a - 1,r = a + tot;
	l = findkth(l) , r = findkth(r);
	splay(l,0),splay(r,l);
	int u = tree[root].ch[1];
	erase(tree[u].ch[0]),tree[u].ch[0] = 0;
	update(u),update(root);
}

void add(int pos,int tot)
{
    for(int i = 1; i <= tot; i++){
        scanf("%d",org + i);
    }
	//将区间[a,b]后接到c后面
	int l = pos,  r = pos + 1;
	l = findkth(l) , r = findkth(r);
	splay(l,0) , splay(r, l);
	int u = tree[root].ch[1];
    build_tree(tree[u].ch[0],1,tot,u);
	update(u),update(root);
}

//获取区间和
int Get_Sum(int pos,int tot)
{
    int l = pos - 1,r = pos + tot;
    l = findkth(l) , r = findkth(r);
	splay(l,0), splay(r,l);
    int u = tree[root].ch[1];
    return tree[tree[u].ch[0]].maxsum;
}

void inorder(int rt)
{
	if(!rt) return ;
	pushdown(rt);
	if(tree[rt].ch[0]) inorder(tree[rt].ch[0]);
	cout<<tree[rt].val<<' ';
	if(tree[rt].ch[1]) inorder(tree[rt].ch[1]);
}

int main()
{
	int n,q;
	char s[2];
	scanf("%d",&n);
	for(int i = 1; i <= n; i++) scanf("%d",org + i + 1);
	org[1] = org[n + 2] = -INF;
	//由于不存在的节点标志为0，所以为了防止update时把0节点也错误计算进去，要对0节点进行赋值
	//-INF是为了防止更新区间最大值的时候，把一些节点的负数值判定为0，造成部分的最大值的和会偏大
	tree[0] = node(-INF),tree[0].size = tree[0].sum = 0;
	build_tree(root,1,n + 2,0);
	scanf("%d",&q);
	while(q--){
		scanf("%s",s);
		int pos,l,r;
		if(s[0] == 'I'){
			scanf("%d",&pos);
			add(pos,1);
		}
		if(s[0] == 'D'){
			scanf("%d",&pos);
			cut(pos + 1,1);
		}
		if(s[0] == 'R'){
			int val;
			scanf("%d%d",&pos,&val);
			Mak(pos + 1,1,val);
		}
		if(s[0] == 'Q'){
			int l,r;
			scanf("%d%d",&l,&r);
			int ans = Get_Sum(l + 1,r - l + 1);
			printf("%d\n",ans);
		}
	}
	//ss;
	return 0;
}
Cu1ii*
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
专题5 数列-2021届高考数学重点专题强化卷（解析版）.pdf
05-15
数列-2021届高考数学重点专题强化卷（解析版）
[NOI2005] 维修数列
weixin_30535167的博客
10-21 73
1500: [NOI2005]维修数列 Time Limit:10 SecMemory Limit:64 MBSubmit:8397Solved:2530 Description Input 输入文件的第1行包含两个数N和M，N表示初始时数列中数的个数，M表示要进行的操作数目。第2行包含N个数字，描述初始时的数列。以下M行，每行一条命令...
YBTOJ&洛谷P2042:维护数列（平衡树）
BUG_Creater_jie的博客
09-24 142
文章目录题目描述解析删除区间插入数列修改&翻转区间和&最大子段和代码 传送门 题目描述 解析 阴间题… 这不是裸的板子吗？ 国赛真的有人能把这题写出来吗… 应该算一道练习作用很强的题了 写完这题，各种平衡树维护区间操作的方法可以说是毕业了吧 题解封装一个split函数的实现技巧值得借鉴 总的来说就一句：不要忘记pushdown和pushup！ 删除区间 设删除区间为[l,r] 先把l-1结点splay到根 再把r+1转到l-1的下面 这样[l,r]一定就在r+1的右儿子了 直接删掉即可 插
1003-Splay-文艺平衡树
Faithfully-xly的博客
10-03 162
这道题没有注明出处，因为各大OJ都有，就随意找地儿测试了(e.g 洛谷，BZOJ……） 文艺平衡树 描述 您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作： 翻转一个区间，例如原有序序列是5 4 3 2 1，翻转区间是[2,4]的话，结果是5 2 3 4 1 输入 第一行为n,m n表示初始序列有n个数，这个序列依次是(1,2……n-1,n) m表示翻转...
[NOI2005]维护数列——平衡树观止
weixin_30347009的博客
09-13 56
本题题解并不详细，不推荐大家看这一篇。 可以看这篇 题目描述 请写一个程序，要求维护一个数列，支持以下 6 种操作：（请注意，格式栏 中的下划线‘ _ ’表示实际输入文件中的空格） 100%的数据中，任何时刻数列中最多含有 500 000 个数。 100%的数据中，任何时刻数列中任何一个数字均在[-1 000, 1 000]内。 100%的数据中，M ≤20 000，插入的数字总数不超...
python-leetcode面试题解之第38题外观数列-python题解.zip
最新发布
03-12
python python_leetcode面试题解之第38题外观数列_python题解
斐波那契数列 - 非常简单：这将打印一组斐波那契数列-matlab开发
05-30
在数学中，斐波那契数列/序列是以下整数序列中的数字 0,1,1,2,3,5,8,13,21,....,. 序列中的前两个数字是0 和 1，后面的每个数字都是前两个的和。
高中数学公式大全-3-数列
01-22
高中数学公式大全-3-数列
95.斐波那契数列-本章总结-高清 1080P
06-01
95.斐波那契数列_本章总结_高清 1080P
程序设计综合实训——高校教师信息管理系统（数据结构，单向链表）
CUCUC1的博客
06-23 4769
其实这个用数组，很容易就可以完成，但是为了学习数据结构，还是用链表写的 题目： 编写一套计算机学院教师信息管理系统，用菜单进行管理，具备输入、显示、查找、排序、插入等功能。每一条记录包括一位教师的职工号、姓名、职称、性别、2门主讲课程，包括课程名称、开课学期、课程性质（必修/限选课）和教学效果，以及教学效果综合评分。 话不多说，直接上代码吧，代码比语言描述清晰 #include <iostream> #include <cstdio> #include <string>
出栈序列
CUCUC1的博客
03-10 1284
已知自然数1,2,…,N(1≤N≤10000)依次入栈（即a<b当且仅当a先于b入栈），问：序列C1,C2,…,CN是否为可能的出栈序列。 　　例如：N=5时，3,4,2,1,5是一个可能的出栈序列，因为其可以按如下操作获得：push 1,push 2,push 3,pop,push 4,pop,pop,pop,push 5,pop Input 输入数据包含若干组测试样例。 　　每组测试样例...
二叉树的应用---后缀表达式构建表达树（poj3367）
CUCUC1的博客
07-28 722
题目链接Expressions 如果不懂什么是后缀表达式构建表达树的 可以参考这篇文章https://blog.csdn.net/qq_26849233/article/details/72910010 题意： 给出一个后缀表达式，让你建成二叉树后，按照下至上，从右至左，将其输出 在建完树之后，按照层序输出然后在把式子反转即可 #include <iostream> #include <cstdio> #include <algorithm> #include <c
Dropping Balls（满二叉树，思维）
CUCUC1的博客
07-28 504
UVA679 小球下落 Dropping Balls 题目翻译： 许多的小球一个一个的从一棵满二叉树上掉下来组成一个新满二叉树，每一时间，一个正在下降的球第一个访问的是非叶子节点。然后继续下降时，或者走右子树，或者走左子树，直到访问到叶子节点。 决定球运动方向的是每个节点的布尔值。最初，所有的节点都是 FALSE，当访问到一个节点时，如果这个节点是 FALSE，则这个球把它变成 TRUE，然后从左子树走，继续它的旅程。如果节点是TRUE，则球也会改变它为 FALSE，而接下来从右子树走。满二叉树的标记方
迷宫问题（dfs）（顺序栈实现）
CUCUC1的博客
06-15 497
传送门 其实吧，走迷宫问题我个人觉得，还是bfs更好一些，但是实验题为了联系栈的使用，估计是把数据针对了一手，bfs跑不了，那就dfs吧 跟正常的dfs一样，但是感觉可以剪下枝，具体的看代码吧，dfs思路还是很简单的 #include <cstdio> #include <cstdlib> #include <iostream> const int MAXN = 105,MAX = 1e3; int maps[MAXN][MAXN],vis[MAXN][MAXN];//
二叉树的建立，前序、中序、后序遍历，层序遍历（递归方式）
CUCUC1的博客
03-28 432
typedef struct node { char data; struct node * left; struct node * right; }Treepoint; //二叉树结点的一种定义方式 建立二叉树，利用递归方式 这里存储的数据是char 型的数据，以‘#’结束。 Treepoint * creatTree() { char ch; Tree...
括号配对（栈和队列）
CUCUC1的博客
04-10 392
Description 假设一个算术表达式中可以包含三种括号：圆括号“(”和“)”，方括号“[”和“]”和花括号“{”和“ ”，且这三种括号可按任意的次序嵌套使用（如：…[…{… …[…]…]…[…]…(…)…)。编写判别给定表达式中所含括号是否正确配对出现的算法。输出结果YES 或者 NO。 Input 5+{[2X5]+2} Output YES Sample Input 8-[{2+7]} ...
线段树 +扫描线
CUCUC1的博客
02-17 345
 关于线段树辅助扫描线的基本思想，已经有很多大佬去详细的解释了，可以去看一下传送门 这里主要说一下线段树辅助扫描线的一些问题以及两种变形 关于数据的离散化，离散化很多时候是为了减小空间消耗，但是我认为在线段树辅助扫描线时，基本都是需要进行离散化的，因为在以x(y)为坐标轴时，维护的是[1, m] (m不确定)，但是显然坐标轴上的区间点坐标不一定是从1开始的，所以要离散出一个区间其范围是 [1, m] 在一般线段树进行区间划分的时候，通常采用下面的方式 mid = l + r >> 1; (操
(可持久化无旋Treap / stl)
CUCUC1的博客
08-08 339
1、利用可持久化无旋Treap 2、利用c++的stl容器crope，内部是用平衡树实现的，操作都是O（logN） 这里直接转了别人的代码 代码出处传送门 #include<iostream> #include<cstdio> #include<ext/rope> #include<string> using namespace std; using namespace __gnu_cxx; const int maxn=50005; crope ro,
斐波那契数列输出-1109825406
10-18
斐波那契数列是指：第一项为0，第二项为1，从第三项开始，每一项都等于前两项之和。因此，斐波那契数列的前几项为：0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ... 如果要输出斐波那契数列的第n项，可以使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值