1. Priority Search Trees
Modified Prof. Sahni’s notes

2. Priority Search Trees Keys are distinct ordered pairs (xi, yi).
Basic operations.
get(x,y) … return element whose key is (x,y).
delete(x,y) … delete and return element whose key is (x,y).
insert(x,y,e) … insert element e, whose key is (x,y).
Rectangle operations.

3. minXinRectangle(xL,xR,yT)
Return element with min x-coordinate in the rectangle defined by the lines, x= xL, x= xR, y = 0, y = yT, xL <= xR, 0 <= yT. xL xR yT
I.e., return element with min x such that
xL <= x <= xR and 0 <= y <= yT.

4. maxXinRectangle(xL,xR,yT)
Return element with max x-coordinate in the rectangle defined by the lines, x= xL, x= xR, y = 0, y = yT, xL <= xR, 0 <= yT. xL xR yT
I.e., return element with max x such that
xL <= x <= xR and 0 <= y <= yT.

5. minYinXrange(xL,xR)
Return element with min y-coordinate in the rectangle defined by the lines, x= xL, x= xR, y = 0, y = infinity, xL <= xR. xL xR
I.e., return element with min y such that
xL <= x <= xR.

6. enumerateRectangle(xL,xR,yT)
Return all elements in the rectangle defined by the lines, x= xL, x= xR, y = 0, y = yT, xL <= xR, 0 <= yT. xL xR yT
I.e., return all elements such that
xL <= x <= xR and 0 <= y <= yT.

7. Complexity
O(log n) for each operation except for enumerateRectangle, where n is the number of elements in the tree.
Complexity of enumerateRectangle is O(log n + s), where s is the number of elements in the rectangle.

8. Applications – Visibility
Dynamic set of semi-infinite vertical line segments.
Vertical lines with end points (xi,infinity) and (xi,yi).
(2,1)
(3,4)
(4,2)
(5,6)
(6,3)
Eye looking right. Determine all lines that are visible to the eye.
Opaque/translucent lines.

9. Translucent Lines y x infinity Eye is at (x,y).
(2,1)
(3,4)
(4,2)
(5,6)
(6,3) x y
Eye is at (x,y).
Priority search tree of line end points.
enumerateRectangle(x, infinity, y).

10. Opaque Lines y x infinity Eye is at (x,y).
(2,1)
(3,4)
(4,2)
(5,6)
(6,3) x y
Eye is at (x,y).
Priority search tree of line end points.
minXinRectangle(x, infinity, y).

11. Online Intersection Of Linear Intervals
Intervals are of the form [i,j], i < j.
[i,j] may, for example represent the fact that a machine is busy from time i to time j.
Answer queries of the form: which intervals intersect/overlap with a given interval [u,v], u < v.
List all machines that are busy at any time between u and v.

12. Example 1 e 3 a 2 4 c 6 b f 5 7 d
Machine a is busy from time 1 to time 3.
Interval is [1,3].
Machines a, b, c, e, and f are busy at some time in the interval [2,4].

13. Example a e f b c d 1 e 3 a 2 4 c 6 b f 5 7 d
Interval [i,j] corresponds to the pair (x,y), where x = j and y = i.
Right end point >= u and left end point <= v. I.e., finish >= u and start <= v.
Finish before 2 or start after 4  not part of answer
Asymptotic performance same as that of interval tree.
enumerateRectangle(u, infinity, v).
enumerateRectangle(2, infinity, 4).

14. Interval Containment
List all intervals [i,j] that contain the interval [u,v].
[i,j] contains [u,v] iff i <= u <= v <= j. 1 e 3 a 2 4 c 6 b f 5 7 d
Intervals b, d, and f contain the interval [5,6].
List all people who are free T,W,F
[u,v] = [5,6]

15. Interval Containment a e f b c d 1 e 3 a 2 4 c 6 b f 5 7 d
Interval [i,j] corresponds to the pair (x,y), where x = j and y = i.
Right of 6 => end at or after 6. Below 5 => start at or before 5.
enumerateRectangle(v, infinity, u).
enumerateRectangle(6, infinity, 5).

16. Intersecting Rectangle PairsF C D E B G
May detect intersecting rectangle pairs by considering bottom horizontal edges as intervals and determining interval intersections with intervals defined by top edges of rectangles. See next slide.
(A,B), (A,C), (D, G), (E,F)
Online interval intersection.

17. Algorithm D A E G F C B Examine horizontal edges in sorted y order.
Bottom edge => insert interval into a priority search tree.
Top edge => report intersecting segments and delete the top edge’s corresponding bottom edge.

18. Complexity Examine edges in sorted order.
Bottom edge => insert interval into a priority search tree.
Top edge => report intersecting segments and delete the top edge’s corresponding bottom edge.
O(n log n) to sort edges by y, where n is # of rectangles.
Insert n intervals … O(n log n).
Report intersecting segments … O(n log n + s).
Delete n intervals … O(n log n).

19. IP Router Table Longest-prefix matching Prefix is an interval
10*, 101*, 1001*
Destination address d = 10100
Longest matching-prefix is 101*
Prefix is an interval
d is 5 bits => 101* = [10100, 10111] = [20,23]
2 prefixes may nest but may not have a proper intersection
Proper intersection means one is not contained in the other and there is an overlap.

20. IP Router Table p(d) = prefixes that match d.
Finish at or after d and start at or before d
p(d) = prefixes that match d.
Use online interval intersection mapping.
p(d) = enumerateRectangle(d,infinity,d)

21. Equivalent problem in 2-dimension
Since the intervals can only nest, for any query minXinRectangle(x,infinity,d), the point with minX is also the point with maxX
left
(d,d)
right

22. IP Router Table d
This remapping doubles the number of bits in f from w to 2w.
Complexity is O(log n) for insert, delete, and find longest matching-prefix.