Are you tired of using traditional data structures for interval assignment operations? Do you want to optimize your algorithm for random data? Look no further than the chtholly tree, the brainchild of competitive programmer Errichto (aka `Algha_Porthos`

).

The chtholly tree is a brute force data structure that uses std::set, a red-black tree implementation in C++, to achieve impressive efficiency in interval assignment operations on random data. While it may not look like a traditional tree structure, the chtholly tree can reach a complexity of O(n \log \log n) in certain cases.

But how does it work? The key lies in its unique approach to storing data. Instead of storing individual values, the chtholly tree stores the differences between adjacent values. This allows it to efficiently update intervals by adding or subtracting the relevant differences.

Errichto first introduced the chtholly tree in a Codeforces blog post in 2017, where he demonstrated its use in solving a range query problem. He has since published several follow-up posts and videos explaining the intricacies of the data structure and its applications in competitive programming.

To give you a taste of the power of the chtholly tree, let's take a look at a simple example. Say we have an array of integers and we want to find the sum of all values in a given interval. Using traditional data structures, we would need to iterate through each value in the interval and add them together, resulting in a complexity of O(n). However, with the chtholly tree, we can store the differences between adjacent values and use `std::set`

to efficiently update the relevant intervals, resulting in a complexity of O(\log n).

```
const int N = 1e5;
int a[N], d[N];
set<int> s;
int main() {
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
d[i] = a[i] - a[i-1];
s.insert(i);
}
while (q--) {
int l, r, x;
cin >> l >> r >> x;
s.insert(l); s.insert(r+1);
auto it = s.lower_bound(l);
while (*it <= r) {
d[*it] += x;
it++;
}
s.erase(l); s.erase(r+1);
}
for (int i = 1; i <= n; i++) {
d[i] += d[i-1];
cout << d[i] << ' ';
}
cout << endl;
return 0;
}
```

In this example, we store the differences between adjacent values in the `d`

array and use `std::set`

to efficiently update intervals. Note that we insert `l`

and `r+1`

into the set to ensure that we cover the entire interval, and we erase them after the updates are complete.

Errichto's contributions to the world of competitive programming extend far beyond the chtholly tree. He is a prolific blogger and YouTuber, sharing his insights and techniques with the community through his videos and posts. His Codeforces profile boasts an impressive rating of over 3200, placing him among the elite programmers in the world.

If you're interested in learning more about the chtholly tree and its applications, be sure to check out Errichto's original blog post, as well as his follow-up posts and videos. With this powerful tool in your arsenal, you'll be well-equipped to tackle even the most complex interval assignment problems in competitive programming. Errichto's contributions to the community have been invaluable, and his expertise in algorithm design and implementation is widely recognized. Whether you're just starting out in competitive programming or you're a seasoned veteran, Errichto's content is sure to be a valuable resource for improving your skills and achieving greater success in competitions. So don't hesitate to explore his Codeforces profile, blog, and YouTube channel to discover more about the chtholly tree and other powerful tools for competitive programming.