Thuật toán Algorithms (Phần 37)
lượt xem 3
download
Thuật toán Algorithms (Phần 37)
Tham khảo tài liệu 'thuật toán algorithms (phần 37)', khoa học tự nhiên, toán học phục vụ nhu cầu học tập, nghiên cứu và làm việc hiệu quả
Bình luận(0) Đăng nhập để gửi bình luận!
Nội dung Text: Thuật toán Algorithms (Phần 37)
 GEOMETRIC INTERSECTION 353 by A is performed on the rightmost tree in the diagram above. This search discovers the intersections between A and E, F, and I. (Recall that although G and J are visited during this search, any points to the left of G or to the right of J would not be touched.) Finally, the upper endpoints of G, J, F, E, and I are encountered, so those points are successively deleted, leading back to the empty tree. The first step in the implementation is to sort the line endpoints on their y coordinate. But since binary trees are going to be used to maintain the status of vertical lines with respect to the horizontal scan line, they may as well be used for the initial y sort! Specifically, we will use two “indirect” binary trees on the line set, one with header node hy and one with header node hx. The y tree will contain all the line endpoints, to be processed in order one at a time; the x tree will contain the lines that intersect the current horizontal scan line. We begin by initializing both hx and hy with 0 keys and pointers to a dummy external node z, as in treeinitialize in Chapter 14. Then the hy tree is constructed by inserting both y coordinates from vertical lines and the y coordinate of horizontal lines into the binary search tree with header node hy, as follows: procedure buildytree; var N, k, xl, yl, x2, y2: integer; begin readln (N) ; for k:=l to N do begin readln (xl, yl , x2, y2) ; lines[k].pl.x:=xl; lines[k].pl.y:=yl; lines[k].p2.x:=x2; lines[k].p2.y:=y2; bstinsert(k, yl, hy); if y2< >yl then b&insert (k, y2, hy) ; end ; end ; This program reads in groups of four numbers which specify lines, and puts them into the lines array and the binary search tree on the y coordinate. The standard b&insert routine from Chapter 14 is used, with the y coordinates as keys, and indices into the array of lines as the info field. For our example set of lines, the following tree is constructed:
 354 CHAPTER 27 Now, the sort on y is effected by a recursive program with the same recursive structure as the treeprint routine for binary search trees in Chapter 14. We visit the nodes in increasing y order by visiting all the nodes in the left subtree of the hy tree, then visiting the root, then visiting all the nodes in the right subtree of the hy tree. At the same time, we maintain a separate tree (rooted at hx) as described above, to simulate the operation of passing a horizontal scan line through. The code at the point where each node is “visited” is rather straightforward from the description above. First, the coordinates of the endpoint of the corresponding line are fetched from the lines array, indexed by the info field of the node. Then the key field in the node is compared against these to determine whether this node corresponds to the upper or the lower endpoint of the line: if it is the lower endpoint, it is inserted into the hx tree, and if it is the upper endpoint, it is deleted from the hx tree and a range search is performed. The implementation differs slightly from this description in that horizontal lines are actually inserted into the hx tree, then immediately deleted, and a range search for a onepoint interval is performed for vertical lines. This makes the code properly handle the case of overlapping vertical lines, which are considered to “intersect.”
 GEOMETRIC INTERSECTION procedure scan (next: link) ; var t, xl, x2, yl, y2: integer; int: interval; begin if next< > z then begin scan(nextf.1); xl:=lines[nextt.info].pl.x; yl :=lines[nextf.info].pl.y; x2:=lines[nextf.info].p2.x; y2:=lines[nextf.info].p2.y; if x2
 356 CHAPTER 27 General Line Intersection When lines of arbitrary slope are allowed, the situation can become more complicated, as illustrated by the following example. First, the various line orientations possible make it necessary to test explicitly whether certain pairs of lines intersect: we can’t get by with a simple interval range test. Second, the ordering relationship between lines for the binary tree is more complicated than before, as it depends on the current y range of interest. Third, any intersections which do occur add new “interesting” y values which are likely to be different from the set of y values that we get from the line endpoints. It turns out that these problems can be handled in an algorithm with the same basic structure as given above. To simplify the discussion, we’ll consider an algorithm for detecting whether or not there exists an intersecting pair in a set of N lines, and then we’ll discuss how it can be extended to return all intersections. As before, we first sort on y to divide the space into strips within which no line endpoints appear. Just as before, we proceed through the sorted list of points, adding each line to a binary search tree when its bottom point is encountered and deleting it when its top point is encountered. Just as before, the binary tree gives the order in which the lines appear in the horizontal
 GEOMETRIC INTERSECTION 357 “strip” between two consecutive y values. For example, in the strip between the bottom endpoint of D and the top endpoint of B in the diagram above, the lines should appear in the order F B D G H. We assume that there are no intersections within the current horizontal strip of interest: our goal is to maintain this tree structure and use it to help find the first intersection. To build the tree, we can’t simply use 5 coordinates from line endpoints as keys (doing this would put B and D in the wrong order in the example above, for instance). Instead, we use a more general ordering relationship: a line x is defined to be to the right of a line y if both endpoints of x are on the same side of y as a point infinitely far to the right, or if y is to the left of 2, with “left” defined analagously. Thus, in the diagram above, B is to the right of A and B is to the right of C (since C is to the left of B). If x is neither to the left nor to the right of y, then they must intersect. This generalized “line comparison” operation is a simple extension of the same procedure of Chapter 24. Except for the use of this function whenever a comparison is needed, the standard binary search tree procedures (even balanced trees, if desired) can be used. For example, the following sequence of diagrams shows the manipulation of the tree for our example between the time that line C is encountered and the time that line D is encountered. 9 B B H F H G G % D Each “comparison” performed during the tree manipulation procedures is actually a line intersection test: if the binary search tree procedure can’t decide to go right or left, then the two lines in question must intersect, and we’re finished. But this is not the whole story, because this generalized comparison operation is not transitive. In the example above, F is to the left of B (because B is to the right of F) and B is to the left of D, but F is not to the left of D. It is essential to note this, because the binary tree deletion procedure assumes that the comparison operation is transitive: when B is deleted from the last tree in the above sequence, the tree
 358 CHAPTER 27 is formed without F and D ever having been explicitly compared. For our intersectiontesting algorithm to work correctly, we must explicitly test that comparisons are valid each time we change the tree structure. Specifically, every time we make the left link of node 5 point to node y, we explicitly test that the line corresponding to x is to the left of the line corresponding to y, according to the above definition, and similarly for the right. Of course, this comparison could result in the detection of an intersection, as it does in our example. In summary, to test for an intersection among a set of N lines, we use the program above, but with the call to range removed, and with the binary tree routines extended to use the generalized comparison as described above. If there is no intersection, we’ll start with a null tree and end with a null tree without finding any incomparable lines. If there is an intersection, then the two lines which intersect must be compared against each other at some point during the scanning process and the intersection discovered. Once we’ve found an intersection, we can’t simply press on and hope to find others, because the two lines that intersect should swap places in the ordering directly after the point of intersection. One way to handle this problem would be to use a priority queue instead of a binary tree for the “ y sort”: initially put lines on the priority queue according to the y coordinates of their endpoints, then work the scan line up by successively taking the smallest y coordinate from the priority queue and doing a binary tree insert or delete as above. When an intersection is found, new entries are added to the priority queue for each line, using the intersection point as the lower endpoint for each. Another way to find all intersections, which is appropriate if not too many are expected, is to simply remove one of the intersecting lines when an intersection is found. Then after the scan is completed, we know that all intersecting pairs must involve one of those lines, so we can use a brute force method to enumerate all the intersections. An interesting feature of the above procedure is that it can be adapted to solve the problem for testing for the existence of an intersecting pair among a set of more general geometric shapes just by changing the generalized comparison procedure. For example, if we implement a procedure which
 GEOMETRIC INTERSECTION 359 compares two rectangles whose edges are horizontal and vertical according to the trivial rule that rectangle 5 is to the left of rectangle y if the right edge of x is to the left of the left edge of y, then we can use the above method to test for intersection among a set of such rectangles. For circles, we can use the x coordinates of the centers for the ordering, but explicitly test for intersection (for example, compare the distance between the centers to the sum of the radii). Again, if this comparison procedure is used in the above method, we have an algorithm for testing for intersection among a set of circles. The problem of returning all intersections in such cases is much more complicated, though the bruteforce method mentioned in the previous paragraph will always work if few intersections are expected. Another approach that will suffice for many applications is simply to consider complicated objects as sets of lines and to use the line intersection procedure. r l
 360 Exercises 1. How would you determine whether two triangles intersect? Squares? Regular ngons for n > 4? 2. In the horizontalvertical line intersection algorithm, how many pairs of lines are tested for intersection in a set of lines with no intersections in the worst case? Give a diagram supporting your answer. 3. What happens if the horizontalvertical line intersection procedure is used on a set of lines with arbitrary slope? 4. Write a program to find the number of intersecting pairs among a set of N random horizontal and vertical lines, each line generated with two random integer coordinates between 0 and 1000 and a random bit to distinguish horizontal from vertical. 5. Give a method for testing whether or not a given polygon is simple (doesn’t intersect itself). 6. Give a method for testing whether one polygon is totally contained within another. 7 Describe how you would solve the general line intersection problem given the additional fact that the minimum separation between two lines is greater than the maximum length of the lines. 8. Give the binary tree structure that exists when the line intersection algorithm detects an intersection in the following set of lines: 9. Are the comparison procedures for circles and Manhattan rectangles that are described in the text transitive? 10. Write a program to find the number of intersecting pairs among a set of N random lines, each line generated with random integer coordinates between 0 and 1000.
 28. Closest Point Problems Geometric problems involving points on the plane usually involve im plicit or explicit treatment of distances between the points. For ex ample, a very natural problem which arises in many applications is the nearest neighbor problem: find the point among a set of given points closest to a given new point. This seems to involve checking the distance from the given point to each point in the set, but we’ll see that much better solutions are possible. In this section we’ll look at some other distance problems, a prototype algorithm, and a fundamental geometric structure called the Voronoi diagram that can be used effectively for a variety of such problems in the plane. Our approach will be to describe a general method for solving closest point problems through careful consideration of a prototype implementation, rather than developing full implementations of programs to solve all of the problems. Some of the problems that we consider in this chapter are similar to the rangesearching problems of Chapter 26, and the grid and 2D tree methods developed there are suitable for solving the nearestneighbor and other prob lems. The fundamental shortcoming of those methods is that they rely on randomness in the point set: they have bad worstcase performance. Our aim in this chapter is to examine yet another general approach that has guaranteed good performance for many problems, no matter what the input. Some of the methods are too complicated for us to examine a full implementation, and they involve sufficient overhead that the simpler methods may do better for actual applications where the point set is not large or where it is sufficiently well dispersed. However, we’ll see that the study of methods with good worst case performance will uncover some fundamental properties of point sets that should be understood even if simpler methods turn out to be more suitable. The general approach that we’ll be examining provides yet another ex ample of the use of doubly recursive procedures to intertwine processing along the two coordinate directions. The two previous methods of this type that 361
 362 CHAPTER 28 we’ve seen (IcD trees and line intersection) have been based on binary search trees; in this case the method is based on mergesort. Closest Pair The closestpair problem is to find the two points that are closest together among a set of points. This problem is related to the nearestneighbor prob lem; though it is not as widely applicable, it will serve us well as a prototype closestpoint problem in that it can be solved with an algorithm whose general recursive structure is appropriate for other problems. It would seem necessary to examine the distances between all pairs of points to find the smallest such distance: for N points this would mean a running time proportional to N2. However, it turns out that we can use sorting to get by with only examining about N log N distances between points in the worst case (far fewer on the average) to get a worstcase running time proportional to N 1ogN (far better on the average). In this section, we’ll examine such an algorithm in detail. The algorithm that we’ll use is based on a straightforward “divideand conquer” strategy. The idea is to sort the points on one coordinate, say the x coordinate, then use that ordering to divide the points in half. The closest pair in the whole set is either the closest pair in one of the halves or the closest pair with one member in each half. The interesting case, of course, is when the closest pair crosses the dividing line: the closest pair in each half can obviously be found by using recursive calls, but how can all the pairs on either side of the dividing line be checked efficiently? Since the only information we seek is the closest pair of the point set, we need examine only points within distance min of the dividing line, where min is the smaller of the distances between the closest pairs found in the two halves. By itself, however, this observation isn’t enough help in the worst case, since there could be many pairs of points very close to the dividing line. For example, all the points in each half could be lined up right next to the dividing line. To handle such situations, it seems necessary to sort the points on y. Then we can limit the number of distance computations involving each point as follows: proceeding through the points in increasing y order, check if each point is inside the vertical strip consisting of all points in the plane within min of the dividing line. For each such point, compute the distance between it and any point also in the strip whose y coordinate is less than the y coordinate of the current point, but not more than min less. The fact that the distance between all pairs of points in each half is at least min means that only a few points are likely to be checked, as demonstrated in our example set of points:
CÓ THỂ BẠN MUỐN DOWNLOAD

Thuật toán Algorithms (Phần 1)
10 p  74  18

Thuật toán Algorithms (Phần 16)
10 p  71  15

Thuật toán Algorithms (Phần 2)
10 p  57  10

Thuật toán Algorithms (Phần 8)
10 p  60  9

Thuật toán Algorithms (Phần 11)
10 p  61  9

Thuật toán Algorithms (Phần 3)
10 p  62  8

Thuật toán Algorithms (Phần 12)
10 p  54  8

Thuật toán Algorithms (Phần 4)
10 p  54  7

Thuật toán Algorithms (Phần 13)
10 p  52  7

Thuật toán Algorithms (Phần 6)
10 p  62  7

Thuật toán Algorithms (Phần 10)
10 p  51  6

Thuật toán Algorithms (Phần 9)
10 p  57  6

Thuật toán Algorithms (Phần 7)
10 p  49  6

Thuật toán Algorithms (Phần 5)
10 p  60  6

Thuật toán Algorithms (Phần 14)
10 p  34  5

Thuật toán Algorithms (Phần 15)
10 p  38  4

Thuật toán Algorithms (Phần 17)
10 p  38  4