## What is a segment tree

Segment tree is a binary search tree. With the idea of divide and conquer algorithm, it divides an interval into some unit intervals, and each unit interval corresponds to a leaf node in the segment tree----------------- Adapted from Baidu Encyclopedia

## Function of line segment tree

Question: Here you are
n
n
n unordered numbers,
q
q
q operations, asking for a certain interval
[
l
,
r
]
[l, r]
The sum of [l,r] or modify the value of this interval. assume
1
<
=
n
,
q
<
=
100
,
000
1 <= n, q <= 100,000
1 < = n, Q < = 100000, the time limit for you is
1
s
1s
1s.

If violence is used? It is assumed that the interval of each modification and query is
[
1
,
n
]
[1, n]
[1,n], then the worst time complexity needs
O
(
q
∗
n
)
O(q*n)
O(q * n), obviously timeout.

At this time, we need to use the magical line segment tree.

Observe its structure:

## Achievements:

By observing the law of node subscript, it can be concluded that the subscripts of the two son nodes of the current node p are
p
∗
2
p*2
p * 2 and
p
∗
2
+
1
p*2 +1
p∗2+1.

Recursive tree building is similar to merge sorting. Time complexity
O
(
n
∗
l
o
g
2
(
n
)
)
O (n*log2(n))
O(n∗log2(n))

void build(int l, int r, int p){ if(l ==r){ tree [p] = a[l]; //Leaf node information return ; } int mid = (l + r) >> 1; // Equivalent to mid = (l + r) / 2, build(l, mid, p << 1); //Left bound interval build(mid + i, r, p << 1|1); //In the right section, P < 1 | 1 is equivalent to p / 2 + 1 tree[p] = tree[p << 1] + tree[p << 1|1]; //Upload son node information }

## Query the information of interval [L,R]:

Assume that every time you access a node
p
p
p is an interval
[
l
,
r
]
[l, r]
[l,r],
m
i
d
=
(
l
+
r
)
/
2
mid = (l + r)/ 2
mid=(l+r)/2

If
[
l
,
r
]
[l, r]
[l,r] happens to be
[
L
,
R
]
[L,R]
[L,R] contains (i.e
L
≤
l
L≤l
L≤l &&
r
≤
R
)
r ≤ R)
r ≤ R), then
p
p
We all need the information of node p.

In other cases, judgment is required
m
i
d
mid
mid and
L
,
R
L,R
50. Relationship of R:

1. If
L
≤
m
i
d
L ≤ mid
L ≤ mid, indicating that we need some information of its left interval.

2. If
R
>
m
i
d
R > mid
R> Mid, indicating that we need some information of its right interval· Finally, all the information sets of the above situations are returned.

int query(int l, int r, int p, int L, int R){ if (L <= l && r <= R) return tree[p]; //If the interval contains, all information of the node will be returned int mid = (l + r) >> 1, ret = 0;// ret is used to save information if (L <= mid) ret += query(l, mid, p << 1, L, R);//Take part of the information of the left section if (R > mid) ret += query(mid + 1, r, p << 1|1，L, R);//Take part of the information of the right section return ret;//Return the above results }

## To modify a location k's information:

Very simple, just find and modify the information of the corresponding leaf node.

void update(int l, int r, int p, int k, int s) { if(l == r){ tree[p] = s; return ; } int mid = (l + r) >> 1; if(k <= mid) update(l, mid, p << 1, k, s); // k < = mid indicates that k is in the left interval else update(mid + 1, r, p << 1 | 1，k, s); // Otherwise, it is in the right interval tree[p] = tree[p << 1]+ tree[p << 1|1]; // Don't forget to update the information of the p node~ }

The time complexity is O ( l o g 2 ( n ) ) O(log2(n)) O(log2(n))

## Modify interval [L,R]

Here's the problem. What if the interval [L,R] modifies the information?

Continue the idea of violence, [L,R] one by one.

Then the time complexity of one modification is
O
(
n
∗
l
o
g
2
(
n
)
)
O(n*log2(n))
O(n * log2(n)), modified
q
q
q times

Time complexity up to
O
(
q
∗
n
∗
l
o
g
2
(
n
)
)
O (q*n*log2(n))
O(q * n * log2(n)), but not as simple violence?

Can it be converted into query time complexity?

That is, we only need to modify the nodes that can be queried by interval query.

For example, total interval
[
1
,
10
]
[1,10]
[1,10], to modify
[
4
,
9
]
[4,9]
[4,9] interval, we only need to modify it
[
4
,
5
]
[4,5]
[4,5],
[
6
,
8
]
[6,8]
[6,8],
[
9
,
9
]
[9,9]
The information of the node where [9,9] is located.

What about the child nodes of these nodes?

The modified interval is marked with lazy. If the sub interval of this interval is accessed next time, this mark will be lowered.

Magic lazy tag for interval modification. Time complexity optimized to O ( l o g 2 ( n ) ) O(log2(n)) O(log2(n))

void update(int l, int r,int p, int L, int R, int s) { if(L <= l && r <= R) { //If the current access interval is included in the interval to be accessed tree[p] += (r - l + 1) * s; //First, update the value of the current node lazy[p] += s; //Label with lazy return ; } int mid = (l + r) >> 1; if(lazy[p] != 0){ //If the current interval is marked with lazy, it needs to be lowered tree[p << 1] += (mid - l + 1) * lazy[p]; tree[p << 1 | 1] += (r - mid) * lazy[p]; //First update the values of the two child nodes lazy[p << 1] += lazy[p]; lazy[p << 1 | 1] += lazy[p]; //Drop tag to two child nodes lazy[p] = 0; //The current node is unmarked } if(L <= mid) update(l, mid, p << 1, L, R, s); // L < = mid indicates that the left interval needs to be updated if(R > mid)update(mid + 1, r, p << 1 | 1，L，R, s); // R > mid indicates that the right interval needs to be updated tree[p] = tree[p << 1] + tree[p << 1|1]; // Don't forget to update the information of the p node }

Magic lazy tag for interval modification. Time complexity optimized to O ( l o g 2 ( n ) ) O (log2(n)) O(log2(n))

int query (int l, int r, int p, int L, int R){ if(L <= l && r <= R) return tree[p]; // If the interval contains, all information of the node will be returned int mid = (l + r) >> 1, ret = 0; // ret is used to save information if(lazy [p] != 0) { //If the current interval is marked with lazy, it needs to be lowered tree[p << 1] += (mid - l + 1) * lazy[p]; tree[p << 1|1] += (r - mid) * lazy[p];//First update the values of the two child nodes lazy[p << 1] += lazy[p]; lazy[p << 1|1] += lazy[p];//Drop tag to two child nodes lazy[p] = 0;//The current node is unmarked } if(L <= mid) ret += query(l, mid, p << 1, L, R); //Take part of the information of the left section if(R > mid) ret += query(mid + 1, r, p << 1|1, L,R); //Take part of the information of the right section return ret;//Return the above results }

## Summary & Precautions:

Tree building time complexity
O
(
n
∗
l
o
g
2
(
n
)
)
O (n*log2(n))
O(n∗log2(n))

Single point / interval update / query time complexity
O
(
l
o
g
2
(
n
)
)
O(log2(n))
O(log2(n))

The time complexity is extremely excellent, and the space needs to be opened
4
∗
n
4* n
4∗n

It is used to process some interval queries and modifications that require divisible interval information