CS 5199 – Competition Programming
and Problem Solving Seminar
Segment Tree
Raunak Kumar
Based on slides by Paul Liu, Kuba Karpierz, Bruno Vacherot, Raunak Kumar
and Jason Chiu for CPSC 490 – Problem Solving in Computer Science at The
University of British Columbia
2019/10/07
Cornell University
Data Structures
You are given an array A of n integers. We want to support the
following operations
• Print the array in sorted order.
• Solution: Just sort the array and print it.
1
Data Structures
You are given an array A of n integers. We want to support the
following operations
• Print the array in sorted order.
• Solution: Just sort the array and print it.
• Additionally, allow insertion/deletion of elements.
• Solution: use a different data structure, like a binary search tree.
1
Data Structures
You are given an array A of n integers. We want to support the
following operations
• Print the array in sorted order.
• Solution: Just sort the array and print it.
• Additionally, allow insertion/deletion of elements.
• Solution: use a different data structure, like a binary search tree.
We have a collection of elements and we would like to support some
operations on these elements.
⇒ Often, the solution is to use specialized data structures.
1
Range Query
You are given an array A of n integers. How efficiently can you
answer these queries?
2
Range Query
You are given an array A of n integers. How efficiently can you
answer these queries?
• sum(i, j) = A[i] + A[i+1] + ... + A[j]
• min(i, j) = min(A[i], ..., A[j])
• Median
• Mode
2
Range Query
You are given an array A of n integers. How efficiently can you
answer these queries?
• sum(i, j) = A[i] + A[i+1] + ... + A[j]
• min(i, j) = min(A[i], ..., A[j])
• Median
• Mode
• What if we allow updates?
2
Range Query with Updates
Given an array A of n integers, perform these queries efficiently:
• update(i, x): set A[i] = x
• sum(i, j): return A[i] + A[i+1] + ... + A[j]
3
Potential Solutions
We could try the following:
• Option 1: Naively perform the 2 queries.
• update(i, x) takes O(1) time
• sum(i, j) takes O(n) time.
4
Potential Solutions
We could try the following:
• Option 1: Naively perform the 2 queries.
• update(i, x) takes O(1) time
• sum(i, j) takes O(n) time.
• Option 2: Precompute the sum in O(n2 ) intervals.
• update(i, x) takes O(n) time, to change O(n) intervals
• sum(i, j) takes O(1) time
4
Potential Solutions
We could try the following:
• Option 1: Naively perform the 2 queries.
• update(i, x) takes O(1) time
• sum(i, j) takes O(n) time.
• Option 2: Precompute the sum in O(n2 ) intervals.
• update(i, x) takes O(n) time, to change O(n) intervals
• sum(i, j) takes O(1) time
Can we do better? Can we do a different type of precomputation that
allows us to update and sum fast?
4
Range Query
Given an array A of n integers, answer these queries quickly:
• update(i, x): sets A[i] = x
• sum(i, j): return A[i] + ... + A[j]
Segment tree can solve this in O(log n) per query.
5
Segment Trees
Basic idea: add a lot of layers!
• Segment tree: group every pair together, then every pair of pairs,
then every pair of that, until you get 1 node
Source: http://scvalex.github.io/articles/SegmentTree.html
6
Segment Trees – Structure, Update
Structure
• Binary tree of log n layers, 1 + 2 + 4 + · · · + n = O(n) nodes
• Leaf node: represent one element
• Internal node: represent union of interval of left + right child
Point Update
• Update leaf
• Update ancestors
7
Segment Trees (Sum Query) – Structure, Update
Structure
• Binary tree of log n layers, 1 + 2 + 4 + · · · + n = O(n) nodes
• Leaf node: store value of one element
• Internal node: store sum of left + right child
Point Update
• Update leaf: change value of leaf node
• Update ancestor: re-compute sum of left + right child
8
Segment Trees (Sum Query) – Point Update
9
Segment Trees (Sum Query) – Point Update
9
Segment Trees (Sum Query) – Point Update
9
Segment Trees (Sum Query) – Point Update
9
Segment Trees (Sum Query) – Point Update
9
Segment Trees – Range Query
Range query
• Start at root and recurse down
• Suppose query for [a, b], current node represent [l, r]
• Case 1: [l, r] ⊆ [a, b], return value of current node
• Case 2: [l, r] ̸⊆ [a, b], recurse then combine answer from children
1. If [l, m] ∩ [a, b] ̸= ∅ recurse left child and get answer
2. If [m + 1, r] ∩ [a, b] ̸= ∅ recurse right child and get answer
3. Combine above two answers
10
Segment Trees – Range Query
Range query
• Start at root and recurse down
• Suppose query for [a, b], current node represent [l, r]
• Case 1: [l, r] ⊆ [a, b], return value of current node
• Case 2: [l, r] ̸⊆ [a, b], recurse then combine answer from children
1. If [l, m] ∩ [a, b] ̸= ∅ recurse left child and get answer
2. If [m + 1, r] ∩ [a, b] ̸= ∅ recurse right child and get answer
3. Combine above two answers
Sum query: add #1 and #2
10
Segment Trees (Sum Query) – Range Query
11
Segment Trees (Sum Query) – Range Query
11
Segment Trees (Sum Query) – Range Query
11
Segment Trees (Sum Query) – Range Query
11
Segment Trees (Sum Query) – Range Query
11
Segment Trees (Sum Query) – Range Query
11
Segment Trees (Sum Query) – Range Query
11
Segment Trees (Sum Query) – Range Query
11
Segment Tree - Construction
• You could call update on each element ⇒ O(n log n)
• Better: fill from leaf upwards layer by layer ⇒ O(n)
12
Segment Tree - Implementation
Approach is similar to e.g. heap implementation
• Store the tree in an array A[1 . . . 2n].
• Root = A[1].
• Children of node i = A[2i] and A[2i + 1].
• Parent of node i = i/2.
13
Segment Tree - Initialize
1 // Set input size as some large power of 2.
2 const int MAXN = 1 << 17;
3
4 // Store segment tree in a flat array.
5 int T[2*MAXN];
14
Segment Tree - Build
1 void build(int A[MAXN]) {
2 // initialize leaf
3 for (int i = 0; i < MAXN; i++)
4 T[MAXN + i] = A[i];
5
6 // initialize internal nodes, bottom up
7 for (int i = MAXN-1; i > 0; i--) {
8 T[i] = T[2*i] + T[2*i+1];
9 }
10 }
15
Segment Tree - Point Update
1 void update(int x, int val) {
2 // Change the leaf node's value.
3 int v = MAXN + x;
4 T[v] = val;
5
6 // Propagate the change all the way to the root.
7 for (int i = v/2; i > 0; i /= 2)
8 T[i] = T[2*i] + T[2*i + 1];
9 }
16
Segment Tree - Range Query
1 int query(int x, int y, int i=1, int l=0, int r=MAXN-1)
2 // [l,r] is completely outside [x,y], return 0
3 if (x > r || y < l) return 0;
4
5 // [l,r] is completely in [x,y], return node value
6 if (x <= l && r <= y) return T[i];
7
8 // Otherwise, recurse on children.
9 return query(x, y, 2*i, l, (l+r)/2)
10 + query(x, y, 2*i+1, (l+r)/2+1, r);
11 }
17
Problem 1
Support the following operations on an array A[1 . . . n]
• update (same as before)
• query(l, r) returns the maximum sum subarray within this
subrange.
18
Problem 1 - Solution
Consider a range [l, r]. How could we get the maximum sum subarray
in this range?
• The answer lies entirely in the left child or entirely in the right.
• The answer could spans the left and right children.
• So ans(l, r) = max{ans(left), ans(right), sum(across)}.
19
Problem 1 - Solution
Consider a range [l, r]. How could we get the maximum sum subarray
in this range?
• The answer lies entirely in the left child or entirely in the right.
• The answer could spans the left and right children.
• So ans(l, r) = max{ans(left), ans(right), sum(across)}.
How do we get the maximum sum subarray that goes across the left
and right children?
19
Problem 1 - Solution
Consider a range [l, r]. How could we get the maximum sum subarray
in this range?
• The answer lies entirely in the left child or entirely in the right.
• The answer could spans the left and right children.
• So ans(l, r) = max{ans(left), ans(right), sum(across)}.
How do we get the maximum sum subarray that goes across the left
and right children?
Clearly, we need to store more information in the nodes.
19
Problem 1 - Solution
Store these information in each node
• Sum of entire subrange contained in the node = node.sum
• Best prefix sum = node.prefix
• Best suffix sum = node.suffix
• Answer = node.ans
Update queries
• node.sum = left.sum + right.sum
• node.prefix = max(left.prefix, left.sum + right.prefix)
• node.suffix = max(right.suffix, left.suffix + right.sum)
• node.ans = max(left.ans, right.ans, left.suffix + right.prefix
Time Complexity: O(log n).
20
Range Updates
So far we have only been dealing with “point updates”, where we
change only a single input element at a time.
21
Range Updates
So far we have only been dealing with “point updates”, where we
change only a single input element at a time.
Suppose now we also need to be update an interval [l, r] – for
example, add 3 to every element in an interval. How do we do this?
21
Range Updates
So far we have only been dealing with “point updates”, where we
change only a single input element at a time.
Suppose now we also need to be update an interval [l, r] – for
example, add 3 to every element in an interval. How do we do this?
Naive way: call update once for each element in the interval.
Time Complexity: O(n log n)! Can we do better?
21
Lazy Propagation
Basic idea
• From range query: range [l, r] = union of ranges represented by
O(log n) nodes, so we can just update value at these nodes!
• Idea: at these nodes, add a “todo” variable saying every leaf in
the subtree needs to be updated by x, don’t recurse further
• Update ancestors as usual
22
Lazy Propagation
Basic idea
• From range query: range [l, r] = union of ranges represented by
O(log n) nodes, so we can just update value at these nodes!
• Idea: at these nodes, add a “todo” variable saying every leaf in
the subtree needs to be updated by x, don’t recurse further
• Update ancestors as usual
What if end point of next update/query interval lands in the middle
of a node with a “todo”?
• Before recursing on children, push the “todo” down one level
• After recursing on children, continue as usual
22
Lazy Propagation – Lazy Update
23
Lazy Propagation – Lazy Update
23
Lazy Propagation – Lazy Update
23
Lazy Propagation – Lazy Update
23
Lazy Propagation – Lazy Update
23
Lazy Propagation – Lazy Update
23
Lazy Propagation – Lazy Update
23
Lazy Propagation – Lazy Update
23
Lazy Propagation – Lazy Update
23
Lazy Propagation – Lazy Update
23
Lazy Propagation – Range Query
24
Lazy Propagation – Range Query
24
Lazy Propagation – Range Query
24
Lazy Propagation – Range Query
24
Lazy Propagation – Range Query
24
Lazy Propagation – Range Query
24
Lazy Propagation – Range Query
24
Lazy Propagation – Range Query
24
Lazy Propagation – Range Query
24
Lazy Propagation – Range Query
24
Feedback
Feedback form: https://forms.gle/HqAufcsFUBNN7yfi7
25
