811312A Data Structures and Algorithms, , Exercise 3 Solutions

Transcription

1 811312A Data Structures and Algorithms, , Exercise 3 Solutions The topic of this exercise is the time complexity of algorithms. Cormen, Chapters 2 and 3 Task 3.1 Imaginary algorithms A and B sort their input arrays. Algorithm A performs 32 nlg(n) operations and algorithm B performs 3 n 2 operations, when the array is of size n. Figure out, when to use algorithm A and when to use algorithm B if the size of the array is known. Solution. Let us find sufficiently large array size for which the quadratic algorithm becomes slower. Here lg stands for base-2 logarithm, hence lg(2 k )= k. We list number of operations, when n is a power of2: k n=2 k A: 32*n*lg(n) B: 3*n 2 = 3*n*n *16*4 = *16*16 = *32*5 = *32*32 = *64*6 = *64*64 = *128*7= *128*128 = etc. When n = 2 6 = 64, the algorithms perform the same number of operations. For arrays smaller than 64, the algorithm B is preferred and for larger arrays the algorithm A is preferred. Task 3.2 Download (from the link below on the page) the code file h3_t2.cpp. Compile the program and execute it (in the class, you can use CodeBlocks or compile from the command prompt). If you compile from the command prompt, type g++ h3_t2.cpp o t2.exe (Windows) or g++ h3_t2.cpp o t2 (Linux). The program lets you select to run one of three algorithms (A,B, and C) with a given input size. Execution time is given as output. Use the program to perform following tasks: a) Write down execution times of algorithm A, when the input size ranges from 500 to Try to predict the execution time, when input size is Check your prediction by executing the program. b) Write down execution times of algorithm B, when the input size ranges from 25 to 200. Try to predict the execution time, when input size is 400. Check your prediction by executing the program. c) Write down execution times of algorithm C, when the input size ranges from to Try to predict the execution time, when input size is Check your prediction by executing the program. Finally, try to estimate the execution time algorithms A and B with input size

2 Solution. When run on the lecturer s computer, the programs gave following execution times. NOTE! In this task, one cannot use compiler s optimization, because the algorithms repeat same operation according to a certain pattern. Hence, optimization may alter the results. NOTE2! In some systems, the performance times do not show in milliseconds. Thus, it is advisable to divide the time (in the code of the program) by the constant CLOCKS_PER_SEC to get the time in seconds. Algorithm A: Size Time (ms) Algorithm B: Size Time (ms) Algorithm C: Size Time (ms) Algorithm A: The times show that doubling the size approximately doubles the execution time. If the size is multiplied by five, the time also gets multiplied by five etc. This kind of growth is called linear (the execution time is of class (n), when the input is of size n). This implies that when input is of size 50000, execution takes approximately five times as much time as with input size Estimated execution time is thus 5*2984 = ca ms. When the program was actually executed with input 50000, value ms was obtained, This is quite close to the estimated value. With input size , we could assume that the execution time would be 100 times the execution time of the input 10000, i.e milliseconds = ca. 300 seconds = 5 minutes. This could a patient tester verify. Algorithm B: The times show that doubling the size approximately quadruples the execution time. If the size is multiplied by five, the time gets multiplied by 25 etc. This kind of growth is called quadratic (the execution time is of class ( n 2 ), when the input is of size n). This implies that when input is of size 400, execution takes four times as much time as with input size 200. Estimated execution time is thus 4*6594= ca ms. When the program was actually executed with input 400, value was obtained. This is again rather close to the estimated value. Finally, we shall estimate the execution time with input size In this case, /100 = , and we can assume that the execution time would be (10 000) 2 times

3 the execution time of the input 100, i.e. 1641*(10 000) 2 ms = s, which is about 5.2 years. This might be too much to actually test by running the program. Algorithm C: Here the execution time appears to double, when input is quadrupled. Hence we might assume that with input size would be four times the execution time of input , because / = 16. Thus we estimate that the time would be 4*1828 = ca ms. When executed, we obtained the value 7391 ms, quite close to estimated time. In this case the algorithms execution time is of class ( n), when the size of the input is n. Task 3.3 Following insertion sort is good, when sorting small arrays. Deduce (and justify) the complexity class of the algorithm. Only the worst case needs to be considered. Input: Array A[0,..,n-1], n >= 1 Output: Ordered array A[0] <= <= A[n-1] INSERTION_SORT(A) 1. for j = 1 to n-1 2. k = A[j] 3. i = j-1 4. while i>=0 && A[i]>k 5. A[i+1] = A[i] 6. i = i-1 7. A[i+1] = k 8. return Solution. Lines 1-3 are executed n-1 times, likewise line 7. If the array is in reverse order (clearly the worst case), the lines 5 and 6 in the while loop will be executed j times in each round, totally n-1 = n(n-1)/2 times. Line 4 is executed each round one more time than the lines inside the loop. Thus in the worst case, line 4 is executed (n-1) + n = n(n-1)/2 + n-1 times. Hence the total number of lines executed in the worst case is 4(n-1) + 2n(n-1)/2 + n(n-1)/2 + n-1 = 4n -4 +n 2 n + 1 +n 2 /2 - n/2 + n -1 = 3n 2 /2 + 7n/ We conclude that in the worst case the complexity of insertion sort is ( n ). It can be shown that the complexity is of the same class also in the average case.

4 Programming task Task 3.4. Programs often need random ordering of object collections. This is called generating a random permutation. Consider following algorithm to produce an array A[0..n-1] that contains a random permutation of numbers 1..n. Input: Number n >= 1. Array A[0,..,n-1]. Output: Array A contains numbers 1..n in a random order. RANDPERM(n,A) 1. for i = 0 to n-1 // Initialize the array to 1,2,,n 2. A[i] = i+1 3. for i = 0 to n-1 4. x = random number between 0..i //0 and i included 5. swap A[i] and A[x] 6. return Program the algorithm (with either C or Python) and measure running time increasing the array size. By which sizes it is practical to run the algorithm? What is the time complexity class of the algorithm, when the size of the array is the measure for the input size? Let us apply the above algorithm. In a deck of cards, there are 52 cards, divided to four suits (hearts, diamonds, clubs, and spades), which all contain 13 cards, numerated from 1 to 13. In a game of poker, the players get initially 5 cards. We want to know the probability of getting a flush (i.e. all cards belonging to same suit). You can estimate this probability by simulation: First, make a correspondence between playing cards and numbers 1,,52. Then generate a large number of random permutations of numbers 1,,52 and count, in how many of these, the first five numbers correspond to cards with same suit. Divide this number with the number of generated permutations and you get an estimate for the desired probability. (Calculated probability is ca ) Solution. The example solution are linked below. From the program s menu you can choose, whether to measure time to produce a random permutation or to estimate the probability of flush by simulation. The permutation algorithm is clearly linear (complexity class is Θ(n), when the size of the array is n). Hence the computation time shold grow linearly according to size of the input. On a test computer, the Python implementation obtained the following times when producing random permutations with various table sizes: Table size Time (s) From the table one can see that it is still reasonable to run Python program to produce permutations up to million objects if that does not have to happen in real-time. C program are, being compiled, usually faster than Python programs. C implementation performed as follows: Table size Time (s) We can notice that the C program produces about 20 times longer permutation than the Python program in the same time.

5 When estimating the probability of flush by simulation, we observe that the probability will be close to theoretically calculated probability, when the number of deals approaches to With the C program one can produce almost 50 times as many deals as with the Python program.