Thuật toán Algorithms (Phần 34)
lượt xem 4
download
Thuật toán Algorithms (Phần 34)
Tham khảo tài liệu 'thuật toán algorithms (phần 34)', 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 34)
 FINDING THE: CONVEXHULL 323 (why not just return the points on the hull in any order?), but output in the ordered form is obviously more useful, and it has been shown that the unordered computation is no easier to do. For all of the algorithms that we consider, it is convenient to do the computation in place: the array used for the original point set is also used to hold the output. The algorithms simply rearrange the points in the original array so that the convex hull appears in the first M positions, in order. From the description above, it may be clear that computing the convex hull is closely related to sorting. In fact, a convex hull algorithm can be used to sort, in the following way. Given N numbers to sort, turn them into points (in polar coordinates) by treating the numbers as angles (suitably normalized) with a fixed radius for each point. The convex hull of this point set is an Ngon containing all of the points. Now, since the output must be ordered in the order the points appear on this polygon, it can be used to find the sorted order of the original values (remember that the input was unordered). This is not a formal proof that computing the convex hull is no easier than sorting, because, for example, the cost of the trigonometric functions required to convert the original numbers to be sorted into points on the polygon must be considered. Comparing convex hull algorithms (which involve trigonometric operations) to sorting algorithms (which involve comparisons bet,ween keys) is a bit like comparing apples to oranges, but it has been shown that any convex hull algorithm must require about N log N operations, the same as sorting (even though the operations allowed are likely to be quite different). It is helpful to view finding the convex hull of a set of points as a kind of “twodimensional sort” because frequent parallels to sorting algorithms arise in the study of algorithms for finding the convex hull. In fact, the algorithms that we’ll study show that finding the convex hull is no harder than sorting either: there are several algorithms that run in time proportional to N log N in the worst case. Many of the algorithms tend to use even less time on actual point sets, because their running time depends on the way that the points are distributed and on the number of points on the hull. We’ll look at three quite different methods for finding the convex hull of a set of points and then discuss their relative running times. Package Wrapping The most natural convex hull algorithm, which parallels the method a human would use to draw the convex hull of a set of points, is a systematic way to “wrap up” the set of points. Starting with some point guaranteed to be on the convex hull (say the one with the smallest y coordinate), take a horizontal ray in the positive direction and “sweep” it upward until hitting another point; this
 324 CHAPTER 25 point must be on the hull. Then anchor at that point and continue “sweeping” until hitting another point, etc., until the “package” is fully “wrapped” (the beginning point is included again). The following diagram shows how the hull is discovered in this way. Of course, we don’t actually sweep through all possible angles, we just do a standard findtheminimum computation to find the point that would be hit next. This method is easily implemented by using the function theta(pl, p2: point) developed in the previous chapter, which can be thought of as returning the angle between pl, p2 and the horizontal (though it actually returns a more easily computed number with the same ordering properties). The following program finds the convex hull of an array p [I..iV] of points, represented as described in the previous chapter (the array position p[N+l] is also used, to hold a sentinel):
 FINDING THE CONVEX HULL 325 function wrap: integer; var i, min, M: integer; minangle, v: real; t: point; begin min:=l; for i:=2 to Ndo if p[i].yv then if theta(p[M], p[i])
 326 CHAPTER 25 7.50(B(A C D E F G H I J K L M N 0 P 18.00 BmC D E F G H I J K L A N 0 P 83.08 B MWD E F G H I J K C A N 0 P 144.00BMLmEFGHIJKCADOP 190.00 B M L NHF G H I J K C A D 0 P 225.00 B M L N EmG H I J K C A D F P 257.14 B M L N E OmH I J K C A D F P 315.00 B M L N E 0 GmI J K C A H F P One attractive feature of this method is that it generalizes to three (or more) dimensions. The convex hull of a set of points in 3space is a convex threedimensional object with flat faces. It can be found by “sweeping” a plane until the hull is hit, then “folding” faces of the plane, anchoring on different lines on the boundary of the hull, until the “package” is “wrapped.” The program is quite similar to selection sorting, in that we successively choose the “best” of the points not yet chosen, using a bruteforce search for the minimum. The major disadvantage of the method is that in the worst case, when all the points fall on the convex hull, the running time is proportional to N2. The Graham Scan The next method that we’ll examine, invented by R. L. Graham in 1972, is interesting because most of the computation involved is for sorting: the algorithm includes a sort followed by a relatively inexpensive (though not im mediately obvious) computation. The algorithm starts with the construction of a simple closed polygon from the points using the method of the previous chapter: sort the points using as keys the theta function values corresponding to the angle from the horizontal made from the line connecting each point with an ‘anchor’ point p[l] (with the lowest y coordinate) so that tracing P~~l,Pk% . . . ,p[N],p[l] gives a closed polygon. For our example set of points, we get the simple closed polygon of the previous section. Note that p[N], p[l], and p[2] are consecutive points on the hull; we’ve essentially run the first iteration of the package wrapping procedure (in both directions). Computation of the convex hull is completed by proceeding around, trying to place each point on the hull and eliminating previously placed points that couldn’t possibly be on the hull. For our example, we consider the points
 FINDING ‘IYE CONVEXHULL 327 in the order B M J L N P K F I E C 0 A H G D. The test for which points to eliminate is not difficult. After each point has been added, we assume that we have eliminated enough points so that what we have traced out so far could be part of the convex hull, based on the points so far seen. The algorithm is based on the fact that all of the point,s in the point set must be on the same side of each edge of the convex hull. Each time we consider a point, we eliminate from the hull any edge which violates this condition. Specifically, the test for eliminating a point is the following: when we come to examine a new point p[i], we eliminate p[k] from the hull if the line between p[k] and p[kl] g oes between p[i] and p[l]. If p[i] and p[l] are on the same side of the line, then p[k] could still be on the hull, so we don’t eliminate it. The following diagram shows the situation for our example when L is considered: l N l K . l F \ ‘P . . \ \ .I \ . J J . M \ B \ The extended line JM runs between L and B, so J couldn’t be on the hull. Now L, N, and P are added to the hull, then P is eliminated when K is considered (because the extended line NP goes between B and K), then F and I are added, leaving the following situation when E is considered.
 328 CHAPTER 25 . \ \ ‘il\ . \J \ M ‘\ B At this point, I must be eliminated because FI runs between E and B, then F and K must be eliminated because NKF runs between E and B. Continuing in this way, we finally arrive back at B, as illustrated below: G
 FINDING THE CONVEX HULL 329 The dotted lines in the diagrams are all the edges that were included, then eliminated. The initial sort guarantees that each point is considered as a possible hull point in turn, because all points considered earlier have a smaller theta value. Each line that survives the “eliminations” has the property that every point is on the same side of it as p[l], which implies that it must be on the hull. Once the basic method is understood, the implementation is straightfor ward. First, the point with the minimum y value is exchanged with p[l]. Next, shellsort (or some other appropriate sorting routine) is used to rear range the points, modified as necessary to compare two points using their theta values with p[l]. Finally, the scan described above is performed. The following program finds the convex hull of the point set p [1..N] (no sentinel is needed): function grahamscan : integer; var i, j, min, M: integer; 1: line; t: point; begin min:=l; for i:=2 to N do if p [i] .y=O; t:=p[M+I]; p[M+I]:=p[i]; p[i]:=t; end ; grahamscan : =M; end ; The loop maintains a partial hull in p[l], . . . , p [Ml, as described in the text, above. For each new i value considered, M is decremented if necessary to eliminate points from the partial hull and then p [i] is exchanged with p [M+1] to (tentatively) add it to the partial hull. The following table shows the contents of the p array each time a new point is considered for our example:
 330 CHAF’TER 25 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 B M~~NPKFIEC~AHGD   B MMJNPKF I E C O A H G D B MLmJmKFIECOAHGD B ML;J’BymF I E C O A H G D   B MLNHJPBI E C O A H G D B MLNKmPJmECOAHGD   B MLNKFWJPNCOAHGD   B M L N IEl F I J P K ICI 0 A H G D B MLN6@I JPKymAHGD   B MLNEMIJPKFCMHGD B MLNEOaJPKFCImGD   B MLNEOANPKFCI  Jlc.lE B MLNEOMHPKFCI J Au B MLNEOGmPKFCI  J A H This table depicts, for i from 4 to hJ, the solution when p[i] is first considered, with p[M] and p[i] boxed. The program as given above could fail if there is more than one point with the lowest y coordinate, unless theta is modified to properly sort collinear points, as described above. (This is a subtle point which the reader may wish to check.) Alternatively, the min computation could be modified to find the point with the lowest x coordinate among all points with the lowest y coordinate, the canonical form described in Chapter 24. One reason that this method is interesting to study is that it is a simple form of backtracking, the algorithm design technique of “try something, if it doesn’t work then try something else” which we’ll see in much more compli cated forms in Chapter 39. Hull Selection Almost any convex hull method can be vastly improved by a method developed independently by W. F. Eddy and R. W. Floyd. The general idea is simple: pick four points known to be on the hull, then throw out everything inside the quadrilateral formed by those four points. This leaves many fewer points to
 FINDING THE CONVEXHULL 331 be considered by, say, the Graham scan or the package wrapping technique. The method could be also applied recursively, though this is usually not worth the trouble. The four points known to be on the hull should be chosen with an eye towards any information available about the input points. In the absence of any information at all, the simplest four points to use are those with the smallest and largest 5 and y coordinates. However, it might be better to adapt the choice of points to the distribution of the input. For example, if all x and y values within certain ranges are equally likely (a rectangular distribution), then choosing four points by scanning in from the corners might be better (find the four points with the largest and smallest sum and difference of the two coordinates). The diagram below shows that only A and J survive the application of this technique to our example set of points. G The recursive version of this technique is very similar to the Quicksort like select procedure for selection that we discussed in Chapter 12. Like that procedure, it is vulnerable to an N2 worstcase running time. For example, if all the original points are on the convex hull, then no points will get thrown out in the recursive step. Like select, the running time is linear on the average, as discussed further below.
 CHAPTER 25 Performance Issues As mentioned in the previous chapter, geometric algorithms are somewhat harder to analyze than algorithms from some of the other areas we’ve studied because the input (and the output) is more difficult to characterize. It often doesn’t make sense to speak of LLrandom” point sets: for example, as N gets large, the convex hull of points drawn from a rectangular distribution is extremely likely to be very close to the rectangle defining the distribution. The algorithms that we’ve looked at depend on different properties of the point set distribution and are thus in practice incomparable, because to compare them analytically would require an understanding of very complicated interactions between littleunderstood properties of point sets. On the other hand, we can say some things about the performance of the algorithms that will help choosing one for a particular application. The easiest of the three to analyze is the Graham scan. It requires time proportional to N log N for the sort and N for the scan. A moment’s reflection is necessary to convince oneself that the scan is linear, since it does have a repeat “loopwithinaloop.” However, it is easy to see that no point is “eliminated” more than once, so the total number of times the code within that repeat loop is iterated must be less than N. The “packagewrapping” technique, on the other hand, obviously takes about MN steps, where M is the number of vertices on the hull. To compare this with the Graham scan analytically would require a formula for M in terms of N, a difficult problem in stochastic geometry. For a circular distribution (and some others) the answer is that M is about N1/3, and for values of N which are not large N‘j3 is comparable to log N (which is the expected value for a rectangular distribution), so this method will compete very favorably with the Graham scan for many practical problems. Of course, the N2 worst case should always be taken into consideration. Analysis of the FloydEddy method requires even more sophisticated stochastic geometry, but the general result is the same as that given by intuition: almost all the points fall inside the quadrilateral and are discarded. This makes the running time of tbe whole convex hull algorithm proportional to N, since most points are examined only once (when they are thrown out). On the average, it doesn’t matter much which method is used after one application of the FloydEddy met,hod, since so few points are likely to be left. However, to protect against the worst case (when all points are on the hull), it is prudent to use the Graham scan. This gives an algorithm which is almost sure to run in linear time in practice and is guaranteed to run in time  _ proportional to N log N. rl
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  66  15

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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