基于链表实现的珂朵莉树
Posted synapse7
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了基于链表实现的珂朵莉树相关的知识,希望对你有一定的参考价值。
以下内容基于 CF896C Willem, Chtholly and Seniorious 来介绍。
珂朵莉树实质上是一种可以维护区间上的分裂与合并的数据结构,但要求数据是随机的,或者有大量的随机合并操作,这样才能保证维护的区间个数是一个很小的值。
一开始,我们用不同的节点表示 [ 1 , 1 ] , [ 2 , 2 ] , . . . , [ n , n ] [1,1],[2,2],...,[n,n] [1,1],[2,2],...,[n,n] 以及该区间上的值。
本题中的“把区间 [ l , r ] [l,r] [l,r] 赋值为 x x x”对应着一个合并操作,若随机到的 [ l , r ] [l,r] [l,r] 范围比较大,则意味着有大量的节点会合并成一个节点。经测试,在若干次随机合并后,区间个数会骤降至一个稳定的范围(大约几十个),这是理解珂朵莉树的关键。
图例:横轴为操作次数,纵轴为区间个数
数据定义
目前主流的实现是基于 set
来维护节点,但由于平均维护的区间个数很小,set
的优势并不明显。相比之下,链表(或数组)能更简洁地维护分裂与合并操作。
typedef long long int64;
struct Block
Block *next; // 链表下一节点
int l, r; // 区间范围
int64 val; // 区间上的值
Block(Block *next, int l, int r, int64 val): next(next), l(l), r(r), val(val)
bool operator<(const Block &b) const return val < b.val;
*root;
基本操作
分裂区间
void split(int mid)
// 遍历链表
for (Block *b = root; b; b = b->next)
// 寻找能包含 mid 和 mid+1 的 [l, r],将其被拆分成 [l, mid] 和 [mid+1, r]
if (b->l <= mid && mid + 1 <= b->r)
b->next = new Block(b->next, mid + 1, b->r, b->val);
b->r = mid;
break;
在操作区间时,由于不能只维护区间的一部分,所以下面的操作进行之前都需要预先分裂区间,再完成相应操作。
// 预分裂,保证后续操作在 [l, r] 内部
void prepare(int l, int r)
split(l - 1);
split(r);
合并区间
void merge(int l, int r, int64 val)
prepare(l, r)
// 遍历链表
for (Block *b = root; b; b = b->next)
// 寻找区间左端点
if (b->l == l)
// 将区间 [b.l, b.r] 修改成 [b.l, r]
b->r = r;
b->val = val;
// 然后寻找与 [b.l, r] 右侧相邻的区间,将当前节点链至该区间
Block *tmp = b->next;
while (tmp && tmp->l <= r) tmp = tmp->next;
b->next = tmp;
break;
// 注:这里没有释放被删除节点的内存,若有需要可自行添加
区间修改与计算
由于数据量很小,枚举整个链表即可。
// 区间更新
void add(int l, int r, int64 val)
prepare(l, r)
for (Block *b = root; b; b = b->next)
if (l <= b->l && b->r <= r) b->val += val;
// 区间第 k 小
int64 kth(int l, int r, int k)
prepare(l, r)
vector<Block> blocks;
for (Block *b = root; b; b = b->next)
if (l <= b->l && b->r <= r)
blocks.emplace_back(*b);
sort(blocks.begin(), blocks.end());
k--;
for (Block b: blocks)
int cnt = b.r - b.l + 1;
if (k >= cnt) k -= cnt;
else return b.val;
// 快速幂
int64 quick_pow(int64 x, int n, int64 mod)
x %= mod;
int64 res = 1 % mod;
for (; n; n >>= 1)
if (n & 1) res = res * x % mod;
x = x * x % mod;
return res;
// 区间幂和
int64 pow_sum(int l, int r, int n, int64 mod)
prepare(l, r)
int64 sum = 0;
for (Block *b = root; b; b = b->next)
if (l <= b->l && b->r <= r)
sum += int64(b->r - b->l + 1) * quick_pow(b->val, n, mod);
return sum % mod;
AC 代码
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long int64;
int64 seed;
// 生成 [0, n-1] 的随机数
int rand(int n)
int64 ret = seed;
seed = (seed * 7 + 13) % int64(1e9 + 7);
return int(ret) % n;
struct Block
Block *next;
int l, r;
int64 val;
Block(Block *next, int l, int r, int64 val): next(next), l(l), r(r), val(val)
bool operator<(const Block &b) const return val < b.val;
*root;
void split(int mid)
for (Block *b = root; b; b = b->next)
if (b->l <= mid && mid + 1 <= b->r)
b->next = new Block(b->next, mid + 1, b->r, b->val);
b->r = mid;
break;
void prepare(int l, int r)
split(l - 1);
split(r);
void add(int l, int r, int64 val)
for (Block *b = root; b; b = b->next)
if (l <= b->l && b->r <= r) b->val += val;
void merge(int l, int r, int64 val)
for (Block *b = root; b; b = b->next)
if (b->l == l)
b->r = r;
b->val = val;
Block *tmp = b->next;
while (tmp && tmp->l <= r) tmp = tmp->next;
b->next = tmp;
break;
int64 kth(int l, int r, int k)
vector<Block> blocks;
for (Block *b = root; b; b = b->next)
if (l <= b->l && b->r <= r)
blocks.emplace_back(*b);
sort(blocks.begin(), blocks.end());
k--;
for (Block b: blocks)
int cnt = b.r - b.l + 1;
if (k >= cnt) k -= cnt;
else return b.val;
int64 quick_pow(int64 x, int n, int64 mod)
x %= mod;
int64 res = 1 % mod;
for (; n; n >>= 1)
if (n & 1) res = res * x % mod;
x = x * x % mod;
return res;
int64 pow_sum(int l, int r, int n, int64 mod)
int64 sum = 0;
for (Block *b = root; b; b = b->next)
if (l <= b->l && b->r <= r)
sum += int64(b->r - b->l + 1) * quick_pow(b->val, n, mod);
return sum % mod;
int main()
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m, v_max;
cin >> n >> m >> seed >> v_max;
root = new Block(nullptr, 0, 0, rand(v_max) + 1);
Block *b = root;
for (int i = 1; i < n; i++)
b->next = new Block(nullptr, i, i, rand(v_max) + 1);
b = b->next;
for (; m; m--)
int op = rand(4) + 1;
int l = rand(n), r = rand(n);
if (l > r) swap(l, r);
int x = op == 3 ? rand(r - l + 1) + 1 : rand(v_max) + 1;
prepare(l, r); // 在所有操作前预分裂
switch (op)
case 1:
add(l, r, x);
break;
case 2:
merge(l, r, x);
break;
case 3:
cout << kth(l, r, x) << '\\n';
break;
default:
int64 y = rand(v_max) + 1;
cout << pow_sum(l, r, x, y) << '\\n';
break;
return 0;
以上是关于基于链表实现的珂朵莉树的主要内容,如果未能解决你的问题,请参考以下文章