To finish up, we're going to look at the rectangle intersection problem that's got

important practical applications and, uses the techniques that we've been studying so

far. And it's a simple generalization of our line intersection problem. So now, we

have a bunch of rectangles. They're all oriented horizontal or vertical. And what

we need to do is find all the intersections in that set of rectangles.

And again N could be huge in applications, as we'll talk about in a second. And the

[cough] Naive Brute-Force Algorithm involves checking each pair of rectangles

for intersection. And what we want is a more efficient algorithm than that as

usual. And again, to keep the code simple we're going to assume that all the

coordinates are distinct. We don't have any, any equal lines that we have to worry

about whether we consider rectangles that touch to be intersecting, and so forth. So

that's, that's the problem, rectangle intersection search. This is historically,

an extremely, important problem. In the 1970s, when we switched to very large

scale integration for computers, we were switching from a situation where we were

wiring physical devices together, to a situation where we were essentially

drawing the computer. And there were machines that would take drawings and, and

return, [cough] and from those drawings, like this, make, physical things that

implemented computers with different layers and different, physical materials

interacting, in different ways. Some things are wires, and some things are

switches that, are used to, implement memory bits and computer logic. But the

key point about it is that designing a computer became a geometric problem. And

so, people, to design new computers, would, make huge drawings that just showed

the lines that corresponded to the materials that had to be created to make

the computer. Now, it was very expensive. You didn't want to have any bugs when

you're making a chip. And, there were various rules about what you can do on

these drawings. And basically, these rules had to do with doing this ortho,

orthogonal rectangle intersection search. You, you can't have [cough] lines that

come too close to other lines, certain types of lines can't intersect. Need

spacing between certain types of wires and, you wanted to, before you tried to

make the physical circuit to do this checking, which involved this orthogonal

rectangle intersection sort. And it was actually the case that the progress of

faster and faster processors with more and more components was slowed because people

were using the naive quadratic algorithm to do this design rule checking. And its

example of, of Moore's law. So, as we built a faster computer say, in 1970X, we

needed to check in rectangles. But now, maybe a year and a half later, you have a

computer that's two times faster but you also want to build a bigger computer so

you have twice as many rectangles to check. So you have two end rectangles to

check now, and your computer's twice as fast. So, we get to use the faster and

bigger computer to build faster and bigger circuits but that doesn't help if you're

using a quadratic algorithm. If you're using a quadratic algorithm and it takes

you n days to check your design rules, and people were running these things on the

order of days, then for the next computer, it would take 2n days, it would take twice

as long. And so people that were using quadratic algorithms were definitely held

back and, it was, Ed, Ed McCreight at Xerox Park who, discovered interval search

trees and the logarithmic algorithm that allowed us to sustain Moore's law and keep

building bigger and bigger computers. By changing this quadratic algorithm to a

linear logarithmic algorithm, and let's see how it works. Really, it's a

modification of the sweep line algorithm that we looked at for intersecting lines.

But now we're going to use that for intersecting rectangles rather than using

range search as our basic operation, we're going to use interval search. So now,

every time the line sweep hits a rectangle, that corresponds to an

interval. If it's the left part of a rectangle, then we put that interval into

our interval search tree. So in this case we put on zero and then we put on one and

then we put on two. And, and that will give us now three rectangles on our sweep

line. And so now, the question is when we hit a, a new rectangle, we want to do an

interval search to, if we're at the left to check which ones intersect and the

interval search tree algorithm is going to tell us which intersections there are

right away. When we reach the right then we remove intervals and so forth. But with

the basic interval search tree algorithm and the sweep line process that we've

talked about, you can get the orthogonal, orthogonal rectangle intersection search

problem solved in time proportional to analog N log N + R log N, where R is the

number of intersections. And typically, in design rule checking, you wouldn't expect

too many intersections. So again, just as with, line intersection search, using a

priority queue or a sort is only N log N for processing the X coordinates. And

because the interval search trees take log N for every operation, the insert and

delete intervals is N log N totaled and the searches is N log N + R log N. So, the

bottom line is that the sweep line algorithm takes this rectangle

intersection problem and reduces it to 1D interval search and we have an efficient

algorithm for that problem and that enables us to solve the problem in linear

rhythmic time instead of quadratic time. And that definitely enabled new progress

in technology and it's a fine example of the importance of algorithmic technology.

So here's our summary of applications of binary search trees for geometric

problems. We started with one dimensional range search and just used regular binary

search tree to compute ranks to get the answer. But that as the basis, we're able

to solve the two dimensional line segment intersection search using the sweep line

algorithm. Then we looked at range search and other operations using KD trees.

Again, modification of binary search trees. And then the interval search tree

to solve the one dimensional N over search problem and then how that corresponds to

the basic algorithm that you get to if you use the sweep line algorithm to solve

rectangle intersection. Many of these problems are the basis for geometric

processing of huge amounts of data that we see all over the web. And our basic search

tree mentality and APIs, and binary search tree data structure give us efficient

solutions to these important practical problems.