# Time Bounds for Selection*

Save this PDF as:

Size: px
Start display at page:

## Transcription

1 JOURNAL OF COMPUTER AND SYSTEM SCIENCES 7, (1973) Time Bounds for Selection* MANUEL BLUM, ROBERT W. FLOYD, VAUGHAN PRATT, RONALD L. RIVEST, AND ROBERT E. TARJAN Department of Computer Science, Stanford University, Stanford, California Received November 14, 1972 The number of comparisons required to select the i-th smallest of n numbers is shown to be at most a linear function of n by analysis of a new selection algorithm--pick. Specifically, no more than n comparisons are ever required. This bound is improved for extreme values of i, and a new lower bound on the requisite number of comparisons is also proved. 1. INTRODUCTION In this paper we present a new selection algorithm, PICK, and derive by an analysis of its efficiency the (surprising) result that the cost of selection is at most a linear function of the number of input items. In addition, we prove a new lower bound for the cost of selection. The selection problem is perhaps best exemplified by the computation of medians. In general, we may wish to select the i-th smallest of a set of n distinct numbers, or the element ranking closest to a given percentile level. Interest in this problem may be traced to the realm of sports and the design of (traditionally, tennis) tournaments to select the first- and second-best players. In 1883, Lewis Carroll published an article [1] denouncing the unfair method by which the second-best player is usually determined in a "knockout tournament" -- the loser of the final match is often not the second-best! (Any of the players who lost only to the best player may be second-best.) Around 1930, Hugo Steinhaus brought the problem into the realm of algorithmic complexity by asking for the minimum number of matches required to (correctly) select both the first- and second-best players from a field of n contestants. In 1932, J. Schreier [8] showed that no more than n + [logg(n)]- 2 matches are required, and in 1964, S. S. Kislitsin [6] proved this number to be necessary as well. Schreier's method uses a knockout tournament to determine the winner, followed by a second knockout tournament among the * This work was supported by the National Science Foundation under grant GJ-992. Copyright I973 by Academic Press, Inc. All rights of reproduction in any form reserved. 448

2 TIME BOUNDS FOR SELECTION 449 (at most) [logs(n)] players who lost matches to the winner, in order to select the runner-up. For values of i larger than 2, the minimum number of matches required to select the i-th best player from n contestants is known only for small values of n. The best previous general selection procedure is due to Hadian and Sobel [4], which requires at most n- i + (i- 1)[log~(n- i + 2)] matches. They create a knockout tournament of n -- i + 2 players and then successively eliminate i- 1 who are "too good" to be the i-th best (using replacement selection). No consistent notation has developed in the literature for the "i-th best." We shall use the following two operators: i 0 S -- (read "i-th of S") the i-th smallest element of S, for 1 ~< i ~ ] S ]. aet Note that the magnitude of i O S increases as i increases. We shall often denote i 0 S by i 0 when S is understood. x p S ~t (read "x's rank in S") the rank of x in S, so that xpsos ~x. The minimum worst-case (minimax) cost, that is, the number of binary comparisons required, to select i 0 will be denoted by f(i, n), where t S[ -- n. We also introduce the notation F(~) ~t lim sup f([~(n- 1)] + 1, n) for 0 ~ c~ ~< 1 3 n---) OO ~F~ to measure the relative difficulty of computing percentile levels. In Sec. 2 we prove our main result, that f(i, n) --0(n), by analysis of the basic selection algorithm, PICK. In Sec. 3 PICK is "tuned-up" to provide our tightest results: and max F(~) <~ ~<~l " " F(~) ~< ~/fl [log2(fi/~)]~, for 0 < a </3, (2) where/3 = in Sec. 4 we derive the lower bound: F(a) ~> 1 +min(~x,l--a), for 0~<c~ 1. (3) There is no evidence to suggest that any of the inequalities (1)-(3) is the best possible. In fact, the authors conjecture that they can be improved considerably. (I) 2. THE NEW SELECTION ALGORITHM, PICK In this section we present the basic algorithm and prove that f(i, n) --d0(n). We assume that it is desired to select i 0 S, where ] S] -- n.

3 450 BLUM ET AL. PICK operates by successively discarding (that is, removing from S) subsets of S whose elements are known to be too large or too small to be i 0, until only i 0 remains. Each subset discarded will contain at least one-quarter of the remaining elements. PICK is quite similar to the algorithm FIND (Hoare [5]), except that the element m about which to partition S is chosen more carefully. PICK will be described in terms of three auxiliary functions b(i, n), c(i, n), and d(i, n), which will be chosen later. We will omit argument lists for these functions in general, as no confusion can arise. Since we are interested in the asymptotic properties of PICK, we will also omit details to be given in Sec. 3 regarding the case when n mod c :A 0. PICK: (Selectsi0S, wherelsl =nandl ~i~<n) 1. (Select an element m ~ S): (a) (b) Arrange S into n/c columns of length c, and sort each column. Select m--b 0 T, where T-'aet the set of n/c elements which are the d-th smallest element from each column. Use PICK recursively if n[c > (Compute m p S): Compare m to every other element x in S for which it is not yet known whether m < x or m > x. 3. (Discard or halt): If m p S -- i, halt (since m -- i 0 S), otherwise if m p S > i, discard D -- {xlx ~ m} and set n ~-- n -- [D [, otherwise discard D = {xlx <~ m} and set n +-- n -- I D 1, i ~ i- I D I. Return to step 1. This completes the description of PICK. We are now ready to prove: THEOREM 1. f (i, n) -- d)(n). Proof. We show that a reasonable choice of functions b(i, n), c(i, n), and d(i, n) result in a linear time selection algorithm. Let h(c) denote the cost of sorting c numbers using Ford and Johnson's algorithm [2]. It is known [3] that: h(c) = ~ Ilog~(3j/4)]. (4) l~<j~c The cost of step l(a) is n h(c)/c, making obvious the fact that c(i, n) must be bounded above by a constant in order for PICK to run in linear time. Letting P(n) denote the maximum cost of PICK for any i, we can bound the cost of step l(b) by P(n/c). After step 1, the partial order determined for S may be represented as in Fig. 1. Here we have the n/c columns of length c portrayed with their largest elements on top. Since the recursive call to PICK in step l(b) determines which elements of T are <m, and which are >m, we separate the columns as in Fig. 1. Every element

4 TIME BOUNDS FOR SELECTION 451 't it q tb tiii i I t't f lilt -.--T = { d- th smallest element from each column } b-1 columns with d-th smallest < m n/c - b Columns with d-th smallest > m FIGURE 1 in box G is clearly greater than m, while every element in box L is less. Therefore, only those elements in quadrants A and B need to be compared to m in step 2. It is easy to show that no elements are ever incorrectly discarded in step 3: if m p S > i, m is too large, so that m and all larger elements may be discarded, and symmetrically for the case m p S < i. Note that at least all of G or all of L will be discarded. It is now obvious that P(n) ~ n. h(c)c ~- P (c) + n + P(n -- min(l L [, L G L)). (5) To minimize P(n) we choose c- 21, d- 11, and b = n/2c = n/42 (so that m is the median of T, and T is the set of column medians). This implies 66n (n) /31n] P(n) <~ -~- + P ~-( + n + P \-~-] (6) since h(21) This implies by mathematical induction that 58n P(n) ~ -~ n. (7) The basis for the induction is that since h(n) < 19n for n < l0 5, any small case can be handled by sorting. PICK runs in linear time because a significant fraction of S is discarded on each pass, at a cost proportional to the number of elements discarded on each step. Note that we must have c >~ 5 for PICK to run in linear time. Q.E.D. 3. IMPROVEMENTS TO PICK The main result that f(i, n) = O(n), has now been proved. We thank the referee for his comment: "The authors have a right to optimize (if they don't, someone else will)." This section contains a detailed analysis of our improved versions of PICK. 57r17/4-9

5 452 BLUM ET AL. We describe two modifications to PICK: PICK1, which yields our best over-all bound for F(a), and PICK2, which is more efficient than PICK1 for i in the ranges i < fin or i :> (1 -- fl)n for fl = The description and analysis of PICK1 is relatively detailed and lengthy--we do not expect the average reader to wade through it! The optimized algorithm is full of red tape, and could not in practice be implemented efficiently, but in principle for any particular n could be expanded into a decision tree without red-tape computation. The basic differences between PICK and PICK1 will be listed shortly. We assume (by arguments of symmetry) that i ~ [n/2] throughout this section. THEOREM 2. F(a) <~ , for 0 ~ ~ <~ 1. Proof. By analysis of PICKI, which differs from PICK in the following respects: (i) The elements of S are sorted into columns only once, after which those columns broken by the discard operation are restored to full length by a (new) merge step at the end of each pass. (ii) The partitioning step is modified so that the number of comparisons used is a linear function of the number of elements eventually discarded. (iii) The discard operation breaks no more than half the columns on each pass, allowing the other modifications to work well. (iv) The sorting step implicit in the recursive call to select m is partially replaced by a merge step for the second and subsequent iterations since (iii) implies that 1/2 of the set T operated on at pass j were also in the recursive call at pass j- 1. The term "k-column" will be used to denote a sorted column of length k. The optimal value of the function c, 15, will be used explicitly throughout for clarity. The algorithm is presented as three separate procedures, each of which selects i 0 S from S, given that the partial order already determined for S is one of three types. Procedure PICKI is the outermost procedure, which assumes that no information is known about the elements of S. PROCEDURE PICK1. 1. If n ~ 45, sort S, print i 9, and halt. (Selects i0 S from S, where IS[ -- n and 1 ~ i ~ [n]2]). 2. Sort S into [n/15j 15-columns and possibly one (n mod 15)-column. 3. Use procedure PICKIa to select i0. PROCEDURE PICKIa. (Same as PICK1, except that S is already sorted into 15- columns). 1. If n ~ 45, sort S, print i 0 S, and halt.

6 TIME BOUNDS FOR SELECTION Sort the set T of column medians into (In/15] mod 15)-column. 3. Use procedure PICKlb to select i 0 S. 15-columns and possibly one PROCEDURE PICKIb. 15-columns). (Same as PICKla, except that T is also already sorted into 1. Use procedure PICKla to select m, the median of T. 2. Partition A u B of Fig. 1 about m as follows, stopping as soon as it becomes clear that mp S -< i or mp S > i: (i) Insert m into each 7-column of B, using binary insertion (3 comparisons/ column). (ii) Insert m into each 7-column of A, using a linear search technique beginning near each 15-column median. 3. If mp S = i, print m (= i0s), and halt, otherwise if mp S > i, discard G u {x [ x ~ B and x > m}, otherwise discard L u {x ] x ~ A and x < m} and decrease i by the number of elements discarded. 4. Restore S to a set of 15-columns by the following merge operations. Here IX] will denote the number of elements in a set X. Let U be the set of columns of lengths <15 (in fact, each column of U has length ~7). Let Y C U be the set of shortest columns of U, such that ]Y f= ]U T/15, and let V be the set of all 7-columns in U- Y. Split U- (V w Y) into two subsets X and W such that W contains w columns, W's columns are not shorter than X's, and I W/-+- [ X[ = 7w. Then (i) Extend every column in W to length 7 by using binary insertion to place each element of X into a column of W. (ii) Now every column in U- Y is a 7-column. Merge them pairwise to form 14-columns. (iii) Use binary insertion to place each element of Y into a 14-column. Now S has been restored to a set of 15-columns. 5. Restore the set T of column medians to I5-columns as follows. Let Z C T be those column medians which were column medians in step 1. The elements of Z are already sorted into columns of size 8 or greater since step 3 of the recursive call at step 1 discarded Z in strings of those sizes. (i) Merge the columns of Z together to form 15-columns and some left-overs, treating each column size separately:

7 454 BLUM ET AL. 8-columns: Merge these pairwise to form 15-columns with one element left over. Write this as 2(8): 8 + 7, 1 leftover. 9-columns: 5(9): 9 + 6, 9 + 6, , no leftovers. 10-columns: 3(10): , , no leftovers. ll-columns: Set aside 1/45 of the 11-columns and break them into 1-columns, then do 4(11)+ 1(1): 11 +4, 11 +4, , no leftovers. 12-columns and larger: set aside some elements for binary insertion into the remaining columns. Sort the leftovers into 15-columns. (ii) Sort T- Z into 15-columns. Now T has been restored to a set of 15- columns. 6. Decrease n by the number of elements discarded in step 5. If n ~< 45, sort 8, print i 0 S and halt, otherwise return to step 1. This completes the description of the algorithm. To analyze PICK1, we introduce the following notation: Pl(n), Pla(n), Plb(n) the maximum costs, respectively, of act procedures PICK1, PICKla, and PICKlb. Since h(15) = 42, we have immediately: v = the number of comparisons made in step act PICKlb (2ii). d ---- the number of elements from A u B act discarded in step PICKlb (3). ga, gb -- the number of elements from A, B act found in step PICKlb (2) to be >m. la, lb -- the number of elements from A, B aet found in step PICKlb (2) to be <m. w, x, y = the number of columns in sets W, X, Y aef in PICKlb (4). Pl(n) ~ (42n/15)+ Pla(n) = 2.8n + Pla(n), (8) Pla(n) ~ (42n/225) + Vlb(n) = 0.186n + Plb(n). (9) The following lemma demonstrates the tradeoff created in step PICKlb(2) between v and d: LEMMA 1. v <~ d + n[30.

8 TIME BOUNDS FOR SELECTION 455 Proof. There are two cases to consider since either L or G is discarded in step PICKlb(3). Case 1 (L is discarded). There can clearly be at most one comparison for every column in A, plus one for each element of A discarded. Case 2 (G is discarded). Thus [L I + Za + Ib -- i + 1 < rn/2] + I ~ [L 1 + [ B! ~< ILl + gb + lb. Thus gb ~ la, but la >/v -- n/30 as in case 1, yielding the lemma since d = gb here. Q.E.D. The following lemma allows the costs of step PICKlb(4) to be bounded: LEMMA 2. [ X I < 6d/7. (11) Proof. We have d >/7(w + x + y) -- 1 W I -- l X [ -- I Y I, and 7w -- [ W[ = [ X l, yielding d >/7x + 7y- 1 Y[ >i- 7x, but 6x ) IX I, so that d >~ 7[X [/6. Q.E.D. Step PICKlb(5i) takes, in the worst case, 21/20 comparisons/element to merge and sort Z into 15-columns (detailed analysis omitted--this happens when Z contains only 8-columns). Since t Z I= n/30, this step takes at most 7n/200 comparisons. We may now write the following recurrence for Plb(n): Simplifying yields Plb(n) <~ Pla([n/15l) + 3(n/30) + (d + n/30) + 3(6d/7) step 1 step 2i step 2ii step 4i 13(7n/30- d)/15 + 4(7n/30- d)/15 + 7n/200 step 4ii step 4iii step 5i + 42(7n/30 -- d)/225 + Plb(lln/15 -- a). step 5ii subsequent iterations 5n /13197n P lb(n) ~ (n_[_ 5d),~ + ~)" (12) The right-hand side of (12) is maximum at d = 0, so that and Plb(n) <~ 13197n/ ~n, Pla(n) <~ n, P1 (n) ~< n. (13) (14) (15)

9 456 BLUM ET AL. Since h(c) h(45) max = < 5.43n, (16) 1~e<45 c 45 the basis for the induction yielding (12) is justified, thus also taking care of steps PICKI(1), PICKle(I), and PICKlb(6), and yielding our theorem. Q.E.D. While PICK1 provides a good uniform bound onf(a), better results can be achieved for values of ~ near 0 or 1. We now present the algorithm PICK2, which yields the following result. THEOREM 3. F(~) ~< n//3 I0.86i[log2([3/~)]o~,for 0 < ~ <~ fl, where/3 = Proof. By analysis of PICK2, which is essentially the same as PICK with the functions b(i, n), c(i, n), and d(i, n) chosen to be i, 2, and 1, respectively, and with the partitioning step eliminated. In detail" PROCEDURE PICK2. (Selects i 0 S, where l S I = n, and i < fin): 1. Compare the elements of S pairwise to form [n/2] pairs and possibly one leftover. 2. If i </3[n/2/use procedure PICK2, otherwise use PICK1, to select m as the i-th smallest element of the set T of lesser elements of each pair. See Fig. 2. (17) One Ie f t - over <_!I 1 ' Y... i-1 pairs Pairs with smaller element > m with smaller element < m FmtmE 2 3. Discard all elements known to be >m, that is, those elements in the circle G of Fig Use procedure PICK1 to select i O S from S. This completes the description of procedure PICK2. Note that this reduces to a simple knockout tournament when i = 1! Using P2(i, n) to denote the maximum number of comparisons used by PICK2 to select i 0, we may derive" P2(i, n) <~ tn/2] + min(pl(tn/2]), P2(i, in/21)) + Pl(2i). (18) step i step 2 step 4

10 TIME BOUNDS FOR SELECTION 457 For particular values of i and n, procedure PICK2 is called t = [log2(fln/i)] times in succession during the recursive calls at step 2, before procedure PICK1 is called. Thus, P2(i, n) <~ ~ [n/2~j + Pl(in/2q) + tpl(2i). 0<j<t (19) This directly implies our theorem. The proper value for fl, , is the largest value such that P2([fln], n) < P l(n). Q.E.D. The results of this section are summarized in Fig. 3, where our bounds for F(a) are plotted against a. It is not unreasonable to conjecture that the true curve for PICK2 r -""---- = PICKI 5.43 ~x ll_ g u~ 'o g o 3 m 2,/ / / / /~ upper bound. for F(~t) ~ tower bound Y" for F (~r) 0 o o,o~ ' o,~o o,1~ o,~_o o,~"" tr FIGURE 3. F(a) is unimodal and peaks at a = I/2. The relative complexity of the algorithm PICK1 leads the authors to conjecture that our upper bound can be significantly improved. 4. A LowER BOUND In this section a lower bound for F(a) is derived through the use of an "adversary" approach (this technique is called the construction of an "oracle" by Knuth. See

11 458 hilum ET AL. for example [7], Sec ) The selection process may be formulated as a game between the selection algorithm (player A), who is trying to find i 0 S with as few comparisons as possible, and his adversary (player B), who is trying to force player A to make as many comparisons as possible. The players take alternate turns: each play by A consists of posing a "comparison question," such as "Is x < y?" (for any x, y ~ S), to which player B on his turn must respond with either "Yes" or "No." Player B's responses may be completely arbitrary, as long as he does not contradict his previous responses to A's questions. When A has extracted enough information from B to determine i 0 S, the game is over. The advantage of this approach is that a nontrivial lower bound for the length of this game can be found, independent of A's strategy, simply by supplying a sufficiently clever strategy for B. The length of this game is of course here the usual minimax cost, that is, f (i, n) ~ef min max c(a, B), A B (20) where c(a, B) is the length of the game between particular A and B strategies. Player B in this game of course plays the role of the "data." A strategy for player B is in effect a rule for calculating a particularly bad (that is, costly) set of data for A's strategy since an actual set of numbers can always be constructed that are consistent with B's replies. A good strategy for player B is thus a procedure for "bugging" any given player A strategy. We will now describe the particular player B strategy which yields our lower bound. As the game progresses there will, of course, be many elements x such that player A has determined enough about x to know that x 4: i 0, that is, either x < i 0 or x > i ~?. Player B will initially consider all elements x ~ S to be members of the set U, meaning that player B (and thus player A as well) is uncertain as to whether x < i 0, x --i 0, or x > i 0. After a while, though, player A will be able to force the issue regarding particular elements, that is, force player B to decide the status of a particular element x ~ U. If B decides that x > i 0, he will remove x from U and place it in set G. Similarly if he decides that x < i 0, he will remove x from U and place it in set L. Both G and L are initially empty. The element that turns out to be i 0 will thus be one (anyone) of the elements still in U, so that as long as ] U ] > 1 the game must continue. Our player B strategy thus attempts to keep U as large as possible for as long as possible. The game must actually consist of two phases as far as B's strategy is concerned. As long as ILl < i- 1 and [Gi < n- i, player B has complete freedom to put an element x 6 U into either L or G. After one of L or G fills up, however, B is quite restricted and must play differently since he is not allowed to make I LI>~ i or [G]/> n- i+ 1. At that time, however, the game "degenerates" in the sense that player A has merely to find the minimum (or maximum) element of U.

12 TIME BOUNDS FOR SELECTION 459 During the first phase, player B will never remove more than one element x from U on a single turn. This will not cause any complications as long as x is a maximal (or minimal) element of U and player B puts x into set G (set L). Each element placed in set G (set L) is assumed to be less than (respectively, greater than) all previous elements placed in that set, as well as greater than (respectively, less than) any elements still remaining in U and L (respectively, U and G). This rule completely defines B's responses except when player A wishes to compare two elements x, y ~ U. In addition, player B will only remove an element from U when A makes such a request. Player B will always restrict membership in U so that every member x c U is either a maximal or minimal element of U (or both) with respect to the partial order already fixed on S by B's previous responses. In fact, B will maintain the even stronger condition that for each element x ~ U, there will be at most one y E U for which it is known Whether x < y or y < x. The partial order for S assumed by B may thus always be diagramed: i set G set U I setl Set U therefore contains only three "element-states," and we define a(x) to be --1, 0, or 1, respectively, according to whether x is the lesser element of a pair, an isolated element, or the greater element of a pair. B's strategy for a comparison between two elements x, y ~ U is now easy to state (we assume without loss of generality that ~(x) ~ a(y)): (i) respond "x is less than y," and (ii) if a(x) = a(y) = 0 do nothing, otherwise if a(x) remove x from U and place it in L, otherwise remove y from U and place it in set G. Essentially B's strategy creates a new pair in U if e(x)= a(y)= 0, otherwise one element is removed from U and the number of pairs in U decreases by one. Let c -- the number of comparisons made so far, and p = the number of pairs currently in U.

13 460 BLUM ET AL. It is simple to verify that B's strategy maintains the condition c--p+21ul -2n (21) as long as the game is still in the first phase (this is clearly true at the start when c -- p and [ U] -- n). At the end of phase one, either L or G is full, so that 1 U I ~n--min(i--l,n--i). (22) Furthermore, it must take player A at least [UI-- 1--p comparisons to finish the game during the second phase since he must at least do the work of finding the smallest (or largest) element of U, which requires 1 U t-- 1 comparisons, of which p have already been made. The total number of comparisons made is thus at least f (i, n) >/ c + [ U l--l--p>/nwmin(i--l,n--i)--l, for 1 ~<i~<n (23) from (21) and (22). Taking the limit as n --+ oo, keeping i -- [a(n -- 1)] + 1, we get This bound is also plotted in Fig. 3. F(a) ~ 1 + min(o~, 1--a). (24) 5. SUMMARY The most important result of this paper is that selection can be performed in linear time, in the worst case. No more than n comparisons are required to select the i-th smallest of n numbers, for any i, 1 ~< i ~< n. This bound can be improved when i is near the ends of its range. A general lower bound is also derived which shows, in particular, that at least 3n/2-2 comparisons are required to compute medians. The authors believe that the constants of proportionality in both the upper and lower bounds can be considerably improved. REFERENCES 1. LEWIS CARROLL, "Lawn Tennis Tournaments," St. James's Gazette (August 1, 1883), pp Reprinted in "The Complete Works of Lewis Carroll," New York Modern Library, L. R. FORD AND S. M. JOHNSON, A tournament problem, The American Mathematical Montly 66 (May 1959), ABDOLLAH HADIAN, Optimality properties of various procedures for ranking n different numbers using only binary comparisons, Technical Report 117, Dept. of Statistics, Univ. of Minnesota, May 1969, Ph.D. thesis.

14 TIME BOUNDS FOR SELECTION ABDOLLAH HADIAN AND MILTON SOBEL, Selecting the t-th largest using binary errorless comparisons, Technical Report 121, Dept. of Statistics, Univ. of Minnesota, May C. A. R. HOaRE, Find (Algorithm 65), Communications of the ACM, July 1961, pp S.S. KISLITSIN, On the selection of the k-th element of an ordered set by pairwise comparisons, Sibirsk Math. Z. 5 (1964), (MR 29, No. 2198) (Russian). 7. DONALD E. KNUTH, "The Art of Computer Programming," Vol. III, Sorting and Searching, Addison-Wesley, J6SFF SCHREt~a, O systemach eliminacjii w turniejach, (On elimination systems in tournaments), Mathesis Polska 7 (1932), (Polish). Printed in Belgium

### Divide-and-Conquer Algorithms Part Four

Divide-and-Conquer Algorithms Part Four Announcements Problem Set 2 due right now. Can submit by Monday at 2:15PM using one late period. Problem Set 3 out, due July 22. Play around with divide-and-conquer

### Divide and Conquer. Textbook Reading Chapters 4, 7 & 33.4

Divide d Conquer Textook Reading Chapters 4, 7 & 33.4 Overview Design principle Divide d conquer Proof technique Induction, induction, induction Analysis technique Recurrence relations Prolems Sorting

### Approximation Algorithms

Approximation Algorithms or: How I Learned to Stop Worrying and Deal with NP-Completeness Ong Jit Sheng, Jonathan (A0073924B) March, 2012 Overview Key Results (I) General techniques: Greedy algorithms

### Large induced subgraphs with all degrees odd

Large induced subgraphs with all degrees odd A.D. Scott Department of Pure Mathematics and Mathematical Statistics, University of Cambridge, England Abstract: We prove that every connected graph of order

### An example of a computable

An example of a computable absolutely normal number Verónica Becher Santiago Figueira Abstract The first example of an absolutely normal number was given by Sierpinski in 96, twenty years before the concept

### CSC 180 H1F Algorithm Runtime Analysis Lecture Notes Fall 2015

1 Introduction These notes introduce basic runtime analysis of algorithms. We would like to be able to tell if a given algorithm is time-efficient, and to be able to compare different algorithms. 2 Linear

### Data Structures and Algorithms Week 3

Data Structures and Algorithms Week 3 1. Divide and conquer 2. Merge sort, repeated substitutions 3. Tiling 4. Recurrences Recurrences Running times of algorithms with recursive calls can be described

### CS420/520 Algorithm Analysis Spring 2010 Lecture 04

CS420/520 Algorithm Analysis Spring 2010 Lecture 04 I. Chapter 4 Recurrences A. Introduction 1. Three steps applied at each level of a recursion a) Divide into a number of subproblems that are smaller

Answers to Homework 1 p. 13 1.2 3 What is the smallest value of n such that an algorithm whose running time is 100n 2 runs faster than an algorithm whose running time is 2 n on the same machine? Find the

### No: 10 04. Bilkent University. Monotonic Extension. Farhad Husseinov. Discussion Papers. Department of Economics

No: 10 04 Bilkent University Monotonic Extension Farhad Husseinov Discussion Papers Department of Economics The Discussion Papers of the Department of Economics are intended to make the initial results

### About the inverse football pool problem for 9 games 1

Seventh International Workshop on Optimal Codes and Related Topics September 6-1, 013, Albena, Bulgaria pp. 15-133 About the inverse football pool problem for 9 games 1 Emil Kolev Tsonka Baicheva Institute

### N E W S A N D L E T T E R S

N E W S A N D L E T T E R S 73rd Annual William Lowell Putnam Mathematical Competition Editor s Note: Additional solutions will be printed in the Monthly later in the year. PROBLEMS A1. Let d 1, d,...,

### CS2223 Algorithms B Term 2013 Exam 2 Solutions

CS2223 Algorithms B Term 2013 Exam 2 Solutions Dec. 3, 2013 By Prof. Carolina Ruiz Dept. of Computer Science WPI PROBLEM 1: Solving Recurrences (15 points) Solve the recurrence T (n) = 2T (n/3) + n using

### Good luck, veel succes!

Final exam Advanced Linear Programming, May 7, 13.00-16.00 Switch off your mobile phone, PDA and any other mobile device and put it far away. No books or other reading materials are allowed. This exam

### CS 840 Fall 2016 Self Organizing Linear Search

CS 840 Fall 2016 Self Organizing Linear Search We will consider searching under the comparison model Binary tree lg n upper and lower bounds This also holds in average case Updates also in O(lg n) Linear

### Divide-and-Conquer Algorithms Part One

Divide-and-Conquer Algorithms Part One Announcements Problem Set One completely due right now. Solutions distributed at the end of lecture. Programming section today in Gates B08 from from 3:45PM 5:00PM.

### CS268: Geometric Algorithms Handout #5 Design and Analysis Original Handout #15 Stanford University Tuesday, 25 February 1992

CS268: Geometric Algorithms Handout #5 Design and Analysis Original Handout #15 Stanford University Tuesday, 25 February 1992 Original Lecture #6: 28 January 1991 Topics: Triangulating Simple Polygons

### The Selection Problem

The Selection Problem The selection problem: given an integer k and a list x 1,..., x n of n elements find the k-th smallest element in the list Example: the 3rd smallest element of the following list

### Comparing Leaf and Root Insertion

30 Research Article SACJ, No. 44., December 2009 Comparing Leaf Root Insertion Jaco Geldenhuys, Brink van der Merwe Computer Science Division, Department of Mathematical Sciences, Stellenbosch University,

### ON THE COMPLEXITY OF THE GAME OF SET. {kamalika,pbg,dratajcz,hoeteck}@cs.berkeley.edu

ON THE COMPLEXITY OF THE GAME OF SET KAMALIKA CHAUDHURI, BRIGHTEN GODFREY, DAVID RATAJCZAK, AND HOETECK WEE {kamalika,pbg,dratajcz,hoeteck}@cs.berkeley.edu ABSTRACT. Set R is a card game played with a

### MOP 2007 Black Group Integer Polynomials Yufei Zhao. Integer Polynomials. June 29, 2007 Yufei Zhao yufeiz@mit.edu

Integer Polynomials June 9, 007 Yufei Zhao yufeiz@mit.edu We will use Z[x] to denote the ring of polynomials with integer coefficients. We begin by summarizing some of the common approaches used in dealing

### MODULAR ARITHMETIC. a smallest member. It is equivalent to the Principle of Mathematical Induction.

MODULAR ARITHMETIC 1 Working With Integers The usual arithmetic operations of addition, subtraction and multiplication can be performed on integers, and the result is always another integer Division, on

### Find-The-Number. 1 Find-The-Number With Comps

Find-The-Number 1 Find-The-Number With Comps Consider the following two-person game, which we call Find-The-Number with Comps. Player A (for answerer) has a number x between 1 and 1000. Player Q (for questioner)

### THE TURING DEGREES AND THEIR LACK OF LINEAR ORDER

THE TURING DEGREES AND THEIR LACK OF LINEAR ORDER JASPER DEANTONIO Abstract. This paper is a study of the Turing Degrees, which are levels of incomputability naturally arising from sets of natural numbers.

### 1. R In this and the next section we are going to study the properties of sequences of real numbers.

+a 1. R In this and the next section we are going to study the properties of sequences of real numbers. Definition 1.1. (Sequence) A sequence is a function with domain N. Example 1.2. A sequence of real

### 8.1 Makespan Scheduling

600.469 / 600.669 Approximation Algorithms Lecturer: Michael Dinitz Topic: Dynamic Programing: Min-Makespan and Bin Packing Date: 2/19/15 Scribe: Gabriel Kaptchuk 8.1 Makespan Scheduling Consider an instance

### Linear Time Selection

Chapter 2 Linear Time Selection Definition 1 Given a sequence x 1, x 2,..., x n of numbers, the ith order statistic is the ith smallest element. Maximum or Minimum When i = 1, it is the minimum element

### Analysis of Approximation Algorithms for k-set Cover using Factor-Revealing Linear Programs

Analysis of Approximation Algorithms for k-set Cover using Factor-Revealing Linear Programs Stavros Athanassopoulos, Ioannis Caragiannis, and Christos Kaklamanis Research Academic Computer Technology Institute

### MATH 289 PROBLEM SET 1: INDUCTION. 1. The induction Principle The following property of the natural numbers is intuitively clear:

MATH 89 PROBLEM SET : INDUCTION The induction Principle The following property of the natural numbers is intuitively clear: Axiom Every nonempty subset of the set of nonnegative integers Z 0 = {0,,, 3,

### Randomized algorithms

Randomized algorithms March 10, 2005 1 What are randomized algorithms? Algorithms which use random numbers to make decisions during the executions of the algorithm. Why would we want to do this?? Deterministic

### max cx s.t. Ax c where the matrix A, cost vector c and right hand side b are given and x is a vector of variables. For this example we have x

Linear Programming Linear programming refers to problems stated as maximization or minimization of a linear function subject to constraints that are linear equalities and inequalities. Although the study

### BX in ( u, v) basis in two ways. On the one hand, AN = u+

1. Let f(x) = 1 x +1. Find f (6) () (the value of the sixth derivative of the function f(x) at zero). Answer: 7. We expand the given function into a Taylor series at the point x = : f(x) = 1 x + x 4 x

### Analysis of Algorithms I: Binary Search Trees

Analysis of Algorithms I: Binary Search Trees Xi Chen Columbia University Hash table: A data structure that maintains a subset of keys from a universe set U = {0, 1,..., p 1} and supports all three dictionary

### Modern Optimization Methods for Big Data Problems MATH11146 The University of Edinburgh

Modern Optimization Methods for Big Data Problems MATH11146 The University of Edinburgh Peter Richtárik Week 3 Randomized Coordinate Descent With Arbitrary Sampling January 27, 2016 1 / 30 The Problem

### CSC148 Lecture 8. Algorithm Analysis Binary Search Sorting

CSC148 Lecture 8 Algorithm Analysis Binary Search Sorting Algorithm Analysis Recall definition of Big Oh: We say a function f(n) is O(g(n)) if there exists positive constants c,b such that f(n)

### Continued Fractions and the Euclidean Algorithm

Continued Fractions and the Euclidean Algorithm Lecture notes prepared for MATH 326, Spring 997 Department of Mathematics and Statistics University at Albany William F Hammond Table of Contents Introduction

### Section Notes 3. The Simplex Algorithm. Applied Math 121. Week of February 14, 2011

Section Notes 3 The Simplex Algorithm Applied Math 121 Week of February 14, 2011 Goals for the week understand how to get from an LP to a simplex tableau. be familiar with reduced costs, optimal solutions,

### The divide and conquer strategy has three basic parts. For a given problem of size n,

1 Divide & Conquer One strategy for designing efficient algorithms is the divide and conquer approach, which is also called, more simply, a recursive approach. The analysis of recursive algorithms often

### Chapter 2 Limits Functions and Sequences sequence sequence Example

Chapter Limits In the net few chapters we shall investigate several concepts from calculus, all of which are based on the notion of a limit. In the normal sequence of mathematics courses that students

### CSE 5311 Homework 2 Solution

CSE 5311 Homework 2 Solution Problem 6.2-6 Show that the worst-case running time of MAX-HEAPIFY on a heap of size n is Ω(lg n). (Hint: For a heap with n nodes, give node values that cause MAX- HEAPIFY

### All trees contain a large induced subgraph having all degrees 1 (mod k)

All trees contain a large induced subgraph having all degrees 1 (mod k) David M. Berman, A.J. Radcliffe, A.D. Scott, Hong Wang, and Larry Wargo *Department of Mathematics University of New Orleans New

### THE SEARCH FOR NATURAL DEFINABILITY IN THE TURING DEGREES

THE SEARCH FOR NATURAL DEFINABILITY IN THE TURING DEGREES ANDREW E.M. LEWIS 1. Introduction This will be a course on the Turing degrees. We shall assume very little background knowledge: familiarity with

### OPTIMAL SELECTION BASED ON RELATIVE RANK* (the "Secretary Problem")

OPTIMAL SELECTION BASED ON RELATIVE RANK* (the "Secretary Problem") BY Y. S. CHOW, S. MORIGUTI, H. ROBBINS AND S. M. SAMUELS ABSTRACT n rankable persons appear sequentially in random order. At the ith

### Writing programs to solve problem consists of a large. how to represent aspects of the problem for solution

Algorithm Efficiency & Sorting Algorithm efficiency Big-O notation Searching algorithms Sorting algorithms 1 Overview 2 If a given ADT (i.e. stack or queue) is attractive as part of a solution How will

### We give a basic overview of the mathematical background required for this course.

1 Background We give a basic overview of the mathematical background required for this course. 1.1 Set Theory We introduce some concepts from naive set theory (as opposed to axiomatic set theory). The

### Prime Numbers. Chapter Primes and Composites

Chapter 2 Prime Numbers The term factoring or factorization refers to the process of expressing an integer as the product of two or more integers in a nontrivial way, e.g., 42 = 6 7. Prime numbers are

### Polynomial Degree and Lower Bounds in Quantum Complexity: Collision and Element Distinctness with Small Range

THEORY OF COMPUTING, Volume 1 (2005), pp. 37 46 http://theoryofcomputing.org Polynomial Degree and Lower Bounds in Quantum Complexity: Collision and Element Distinctness with Small Range Andris Ambainis

### SHARP BOUNDS FOR THE SUM OF THE SQUARES OF THE DEGREES OF A GRAPH

31 Kragujevac J. Math. 25 (2003) 31 49. SHARP BOUNDS FOR THE SUM OF THE SQUARES OF THE DEGREES OF A GRAPH Kinkar Ch. Das Department of Mathematics, Indian Institute of Technology, Kharagpur 721302, W.B.,

### 1 Approximating Set Cover

CS 05: Algorithms (Grad) Feb 2-24, 2005 Approximating Set Cover. Definition An Instance (X, F ) of the set-covering problem consists of a finite set X and a family F of subset of X, such that every elemennt

### arxiv: v1 [cs.na] 21 Jan 2014

Solving Cubic Equations By the Quadratic Formula Bahman Kalantari Department of Computer Science, Rutgers University, NJ kalantari@cs.rutgers.edu arxiv:1401.5148v1 [cs.na] 21 Jan 2014 Abstract Let p(z)

### Regular Languages and Finite Automata

Regular Languages and Finite Automata 1 Introduction Hing Leung Department of Computer Science New Mexico State University Sep 16, 2010 In 1943, McCulloch and Pitts [4] published a pioneering work on a

### Chapters 1 and 5.2 of GT

Subject 2 Spring 2014 Growth of Functions and Recurrence Relations Handouts 3 and 4 contain more examples;the Formulae Collection handout might also help. Chapters 1 and 5.2 of GT Disclaimer: These abbreviated

### Merge Sort and Recurrences. COSC 581, Algorithms January 14, 2014

Merge Sort and Recurrences COSC 581, Algorithms January 14, 2014 Reading Assignments Today s class: Chapter 2, 4.0, 4.4 Reading assignment for next class: Chapter 4.2, 4.5 3 Common Algorithmic Techniques

### CS 4310 HOMEWORK SET 1

CS 4310 HOMEWORK SET 1 PAUL MILLER Section 2.1 Exercises Exercise 2.1-1. Using Figure 2.2 as a model, illustrate the operation of INSERTION-SORT on the array A = 31, 41, 59, 26, 41, 58. Solution: Assume

### ! Solve problem to optimality. ! Solve problem in poly-time. ! Solve arbitrary instances of the problem. #-approximation algorithm.

Approximation Algorithms 11 Approximation Algorithms Q Suppose I need to solve an NP-hard problem What should I do? A Theory says you're unlikely to find a poly-time algorithm Must sacrifice one of three

### Binary Search. Search for x in a sorted array A.

Divide and Conquer A general paradigm for algorithm design; inspired by emperors and colonizers. Three-step process: 1. Divide the problem into smaller problems. 2. Conquer by solving these problems. 3.

### A Mathematical Analysis of The Generalized Oval Track Puzzle

Rose- Hulman Undergraduate Mathematics Journal A Mathematical Analysis of The Generalized Oval Track Puzzle Samuel Kaufmann a Volume 12, no. 1, Spring 2011 Sponsored by Rose-Hulman Institute of Technology

### 28 Closest-Point Problems -------------------------------------------------------------------

28 Closest-Point Problems ------------------------------------------------------------------- Geometric problems involving points on the plane usually involve implicit or explicit treatment of distances

### Recurrence Relations

Recurrence Relations Introduction Determining the running time of a recursive algorithm often requires one to determine the big-o growth of a function T (n) that is defined in terms of a recurrence relation.

### Near Optimal Solutions

Near Optimal Solutions Many important optimization problems are lacking efficient solutions. NP-Complete problems unlikely to have polynomial time solutions. Good heuristics important for such problems.

### Partitioning edge-coloured complete graphs into monochromatic cycles and paths

arxiv:1205.5492v1 [math.co] 24 May 2012 Partitioning edge-coloured complete graphs into monochromatic cycles and paths Alexey Pokrovskiy Departement of Mathematics, London School of Economics and Political

### The Relative Worst Order Ratio for On-Line Algorithms

The Relative Worst Order Ratio for On-Line Algorithms Joan Boyar 1 and Lene M. Favrholdt 2 1 Department of Mathematics and Computer Science, University of Southern Denmark, Odense, Denmark, joan@imada.sdu.dk

### Graph Security Testing

JOURNAL OF APPLIED COMPUTER SCIENCE Vol. 23 No. 1 (2015), pp. 29-45 Graph Security Testing Tomasz Gieniusz 1, Robert Lewoń 1, Michał Małafiejski 1 1 Gdańsk University of Technology, Poland Department of

### Two Versus One Index Register and Modifiable Versus Non-modifiable Programs *

Two Versus One Index Register and Modifiable Versus Non-modifiable Programs * by K. Mehlhorn W. J. Paul FB 10 - Informatik Universit t des Saarlandes D-Saarbriicken, West Germany Abstract: We compare Random

### Multi-layer Structure of Data Center Based on Steiner Triple System

Journal of Computational Information Systems 9: 11 (2013) 4371 4378 Available at http://www.jofcis.com Multi-layer Structure of Data Center Based on Steiner Triple System Jianfei ZHANG 1, Zhiyi FANG 1,

### ON INDUCED SUBGRAPHS WITH ALL DEGREES ODD. 1. Introduction

ON INDUCED SUBGRAPHS WITH ALL DEGREES ODD A.D. SCOTT Abstract. Gallai proved that the vertex set of any graph can be partitioned into two sets, each inducing a subgraph with all degrees even. We prove

### CHAPTER II THE LIMIT OF A SEQUENCE OF NUMBERS DEFINITION OF THE NUMBER e.

CHAPTER II THE LIMIT OF A SEQUENCE OF NUMBERS DEFINITION OF THE NUMBER e. This chapter contains the beginnings of the most important, and probably the most subtle, notion in mathematical analysis, i.e.,

### Induction and Recursion

Induction and Recursion Winter 2010 Mathematical Induction Mathematical Induction Principle (of Mathematical Induction) Suppose you want to prove that a statement about an integer n is true for every positive

### Chapter 6 Finite sets and infinite sets. Copyright 2013, 2005, 2001 Pearson Education, Inc. Section 3.1, Slide 1

Chapter 6 Finite sets and infinite sets Copyright 013, 005, 001 Pearson Education, Inc. Section 3.1, Slide 1 Section 6. PROPERTIES OF THE NATURE NUMBERS 013 Pearson Education, Inc.1 Slide Recall that denotes

### Scheduling Single Machine Scheduling. Tim Nieberg

Scheduling Single Machine Scheduling Tim Nieberg Single machine models Observation: for non-preemptive problems and regular objectives, a sequence in which the jobs are processed is sufficient to describe

### Notes from Week 1: Algorithms for sequential prediction

CS 683 Learning, Games, and Electronic Markets Spring 2007 Notes from Week 1: Algorithms for sequential prediction Instructor: Robert Kleinberg 22-26 Jan 2007 1 Introduction In this course we will be looking

### A General Purpose Local Search Algorithm for Binary Optimization

A General Purpose Local Search Algorithm for Binary Optimization Dimitris Bertsimas, Dan Iancu, Dmitriy Katz Operations Research Center, Massachusetts Institute of Technology, E40-147, Cambridge, MA 02139,

### Notes on Cholesky Factorization

Notes on Cholesky Factorization Robert A. van de Geijn Department of Computer Science Institute for Computational Engineering and Sciences The University of Texas at Austin Austin, TX 78712 rvdg@cs.utexas.edu

### COLORED GRAPHS AND THEIR PROPERTIES

COLORED GRAPHS AND THEIR PROPERTIES BEN STEVENS 1. Introduction This paper is concerned with the upper bound on the chromatic number for graphs of maximum vertex degree under three different sets of coloring

### Some Polynomial Theorems. John Kennedy Mathematics Department Santa Monica College 1900 Pico Blvd. Santa Monica, CA 90405 rkennedy@ix.netcom.

Some Polynomial Theorems by John Kennedy Mathematics Department Santa Monica College 1900 Pico Blvd. Santa Monica, CA 90405 rkennedy@ix.netcom.com This paper contains a collection of 31 theorems, lemmas,

### Single machine models: Maximum Lateness -12- Approximation ratio for EDD for problem 1 r j,d j < 0 L max. structure of a schedule Q...

Lecture 4 Scheduling 1 Single machine models: Maximum Lateness -12- Approximation ratio for EDD for problem 1 r j,d j < 0 L max structure of a schedule 0 Q 1100 11 00 11 000 111 0 0 1 1 00 11 00 11 00

### A simple algorithm with no simple verication

A simple algorithm with no simple verication Laszlo Csirmaz Central European University Abstract The correctness of a simple sorting algorithm is resented, which algorithm is \evidently wrong" at the rst

### POWER SETS AND RELATIONS

POWER SETS AND RELATIONS L. MARIZZA A. BAILEY 1. The Power Set Now that we have defined sets as best we can, we can consider a sets of sets. If we were to assume nothing, except the existence of the empty

### MATHEMATICAL INDUCTION AND DIFFERENCE EQUATIONS

1 CHAPTER 6. MATHEMATICAL INDUCTION AND DIFFERENCE EQUATIONS 1 INSTITIÚID TEICNEOLAÍOCHTA CHEATHARLACH INSTITUTE OF TECHNOLOGY CARLOW MATHEMATICAL INDUCTION AND DIFFERENCE EQUATIONS 1 Introduction Recurrence

### CS473 - Algorithms I

CS473 - Algorithms I Lecture 9 Sorting in Linear Time View in slide-show mode 1 How Fast Can We Sort? The algorithms we have seen so far: Based on comparison of elements We only care about the relative

### 2.5 Gaussian Elimination

page 150 150 CHAPTER 2 Matrices and Systems of Linear Equations 37 10 the linear algebra package of Maple, the three elementary 20 23 1 row operations are 12 1 swaprow(a,i,j): permute rows i and j 3 3

### O(n) linear time This means that the algorithm requires a number of steps proportional to the size of the task.

Time complexity : Big O notation f(n) = O(g(n)) means There are positive constants c and k such that: 0

### NP-Completeness I. Lecture 19. 19.1 Overview. 19.2 Introduction: Reduction and Expressiveness

Lecture 19 NP-Completeness I 19.1 Overview In the past few lectures we have looked at increasingly more expressive problems that we were able to solve using efficient algorithms. In this lecture we introduce

### 9th Max-Planck Advanced Course on the Foundations of Computer Science (ADFOCS) Primal-Dual Algorithms for Online Optimization: Lecture 1

9th Max-Planck Advanced Course on the Foundations of Computer Science (ADFOCS) Primal-Dual Algorithms for Online Optimization: Lecture 1 Seffi Naor Computer Science Dept. Technion Haifa, Israel Introduction

### CHAPTER 3 Numbers and Numeral Systems

CHAPTER 3 Numbers and Numeral Systems Numbers play an important role in almost all areas of mathematics, not least in calculus. Virtually all calculus books contain a thorough description of the natural,

### 3 Does the Simplex Algorithm Work?

Does the Simplex Algorithm Work? In this section we carefully examine the simplex algorithm introduced in the previous chapter. Our goal is to either prove that it works, or to determine those circumstances

### Applied Algorithm Design Lecture 5

Applied Algorithm Design Lecture 5 Pietro Michiardi Eurecom Pietro Michiardi (Eurecom) Applied Algorithm Design Lecture 5 1 / 86 Approximation Algorithms Pietro Michiardi (Eurecom) Applied Algorithm Design

### ERDOS PROBLEMS ON IRREGULARITIES OF LINE SIZES AND POINT DEGREES A. GYARFAS*

BOLYAI SOCIETY MATHEMATICAL STUDIES, 11 Paul Erdos and his Mathematics. II, Budapest, 2002, pp. 367-373. ERDOS PROBLEMS ON IRREGULARITIES OF LINE SIZES AND POINT DEGREES A. GYARFAS* Problems and results

Adaptive Online Gradient Descent Peter L Bartlett Division of Computer Science Department of Statistics UC Berkeley Berkeley, CA 94709 bartlett@csberkeleyedu Elad Hazan IBM Almaden Research Center 650

### Week 5 Integral Polyhedra

Week 5 Integral Polyhedra We have seen some examples 1 of linear programming formulation that are integral, meaning that every basic feasible solution is an integral vector. This week we develop a theory

### On line construction of suffix trees 1

(To appear in ALGORITHMICA) On line construction of suffix trees 1 Esko Ukkonen Department of Computer Science, University of Helsinki, P. O. Box 26 (Teollisuuskatu 23), FIN 00014 University of Helsinki,

### COMP 250 Fall Mathematical induction Sept. 26, (n 1) + n = n + (n 1)

COMP 50 Fall 016 9 - Mathematical induction Sept 6, 016 You will see many examples in this course and upcoming courses of algorithms for solving various problems It many cases, it will be obvious that

### FUZZY CLUSTERING ANALYSIS OF DATA MINING: APPLICATION TO AN ACCIDENT MINING SYSTEM

International Journal of Innovative Computing, Information and Control ICIC International c 0 ISSN 34-48 Volume 8, Number 8, August 0 pp. 4 FUZZY CLUSTERING ANALYSIS OF DATA MINING: APPLICATION TO AN ACCIDENT

### A. V. Gerbessiotis CS Spring 2014 PS 3 Mar 24, 2014 No points

A. V. Gerbessiotis CS 610-102 Spring 2014 PS 3 Mar 24, 2014 No points Problem 1. Suppose that we insert n keys into a hash table of size m using open addressing and uniform hashing. Let p(n, m) be the

### Two General Methods to Reduce Delay and Change of Enumeration Algorithms

ISSN 1346-5597 NII Technical Report Two General Methods to Reduce Delay and Change of Enumeration Algorithms Takeaki Uno NII-2003-004E Apr.2003 Two General Methods to Reduce Delay and Change of Enumeration

### Classification - Examples

Lecture 2 Scheduling 1 Classification - Examples 1 r j C max given: n jobs with processing times p 1,...,p n and release dates r 1,...,r n jobs have to be scheduled without preemption on one machine taking

### Introduction to Algorithms March 10, 2004 Massachusetts Institute of Technology Professors Erik Demaine and Shafi Goldwasser Quiz 1.

Introduction to Algorithms March 10, 2004 Massachusetts Institute of Technology 6.046J/18.410J Professors Erik Demaine and Shafi Goldwasser Quiz 1 Quiz 1 Do not open this quiz booklet until you are directed

### ECEN 5682 Theory and Practice of Error Control Codes

ECEN 5682 Theory and Practice of Error Control Codes Convolutional Codes University of Colorado Spring 2007 Linear (n, k) block codes take k data symbols at a time and encode them into n code symbols.

### 2.3 Scheduling jobs on identical parallel machines

2.3 Scheduling jobs on identical parallel machines There are jobs to be processed, and there are identical machines (running in parallel) to which each job may be assigned Each job = 1,,, must be processed

### Linear Systems. Singular and Nonsingular Matrices. Find x 1, x 2, x 3 such that the following three equations hold:

Linear Systems Example: Find x, x, x such that the following three equations hold: x + x + x = 4x + x + x = x + x + x = 6 We can write this using matrix-vector notation as 4 {{ A x x x {{ x = 6 {{ b General