Download presentation

Presentation is loading. Please wait.

1
MS 101: Algorithms Instructor Neelima Gupta ngupta@cs.du.ac.in

2
TOC Lower Bounds (adversary)

3
Lower Bounds Any algorithm to find min and max of n keys by comparison of keys must do at least 3n/2 – 2 comparisons in the worst case. Proof: –Assume that the keys are distinct –Let x denotes max and y denotes min –We must know that every key other than x has lost to some comparison ----- n-1 unit of information required. –Also, we must know that every key other than y has won in some comparison ----- n-1 unit of information required. –Total : 2n – 2 unit of information required to declare that x is max and y is min.

4
Adversary Devises a strategy that gives away minimum information. Key status Meaning W Has won at least one comparison and never lost L Has lost at least one comparison and never won WL Has won and lost at least one comparison N Has not yet participated in a comparison

5
Status of keys x and y compared by an algo Adversary chooses New status Units of new information N,Nx >yW,L2 W,N/ WL, Nx > y…,L1 L,Nx < y…, W1 W,Wx > y…,WL1 L,Lx > yWL,…1 W,L/WL,L/W,W L x > yNo change 0 WL,WLConsistent with assigned values No Change 0

6
Make sure that input constructed is consistent.

7
Example: Constructing an input using adversary’s rules. Comparison x1 x2 X3 x4 x5 x6 status value status value status value status value status value status value INITIAL N * N * N * N * N * N * X1.X2 X1,X5 X3,X4 X3,X6 X3,X1 X2,X4 X5,X6 X6,X4 TABLE 5.3

8
Example: Constructing an input using adversary’s rules. Comparison x1 x2 X3 x4 x5 x6 status value status value status value status value status value status value INITIAL N * N * N * N * N * N * X1.X2 X1,X5 X3,X4 X3,X6 X3,X1 X2,X4 X5,X6 X6,X4 TABLE 5.3

9
Example: Constructing an input using adversary’s rules. Comparison x1 x2 X3 x4 x5 x6 status value status value status value status value status value status value INITIAL N * N * N * N * N * N * X1,X2 W 20 L 10 N * N * N * N * X1,X5 X3,X4 X3,X6 X3,X1 X2,X4 X5,X6 X6,X4 TABLE 5.3

10
Example: Constructing an input using adversary’s rules. Comparison x1 x2 X3 x4 x5 x6 status value status value status value status value status value status value INITIAL N * N * N * N * N * N * X1,X2 W 20 L 10 N * N * N * N * X1,X5 W 20 L 5 X3,X4 X3,X6 X3,X1 X2,X4 X5,X6 X6,X4 TABLE 5.3

11
Example: Constructing an input using adversary’s rules. Comparison x1 x2 X3 x4 x5 x6 status value status value status value status value status value status value INITIAL N * N * N * N * N * N * X1,X2 W 20 L 10 N * N * N * N * X1,X5 W 20 L 5 X3,X4 W 15 L 8 X3,X6 X3,X1 X2,X4 X5,X6 X6,X4 TABLE 5.3

12
Example: Constructing an input using adversary’s rules. Comparison x1 x2 X3 x4 x5 x6 status value status value status value status value status value status value INITIAL N * N * N * N * N * N * X1,X2 W 20 L 10 N * N * N * N * X1,X5 W 20 L 5 X3,X4 W 15 L 8 X3,X6 W 15 L 12 X3,X1 X2,X4 X5,X6 X6,X4 TABLE 5.3

13
Example: Constructing an input using adversary’s rules. Comparison x1 x2 X3 x4 x5 x6 status value status value status value status value status value status value INITIAL N * N * N * N * N * N * X1,X2 W 20 L 10 N * N * N * N * X1,X5 W 20 L 5 X3,X4 W 15 L 8 X3,X6 W 15 L 12 X3,X1 WL 20 W 25 X2,X4 X5,X6 X6,X4 TABLE 5.3

14
Example: Constructing an input using adversary’s rules. Comparison x1 x2 X3 x4 x5 x6 status value status value status value status value status value status value INITIAL N * N * N * N * N * N * X1,X2 W 20 L 10 N * N * N * N * X1,X5 W 20 L 5 X3,X4 W 15 L 8 X3,X6 W 15 L 12 X3,X1 WL 20 W 25 X2,X4 WL 10 L 8 X5,X6 X6,X4 TABLE 5.3

15
Example: Constructing an input using adversary’s rules. Comparison x1 x2 X3 x4 x5 x6 status value status value status value status value status value status value INITIAL N * N * N * N * N * N * X1,X2 W 20 L 10 N * N * N * N * X1,X5 W 20 L 5 X3,X4 W 15 L 8 X3,X6 W 15 L 12 X3,X1 WL 20 W 25 X2,X4 WL 10 L 8 X5,X6 WL 5 L 3 X6,X4 TABLE 5.3

16
Example: Constructing an input using adversary’s rules. Comparison x1 x2 X3 x4 x5 x6 status value status value status value status value status value status value INITIAL N * N * N * N * N * N * X1,X2 W 20 L 10 N * N * N * N * X1,X5 W 20 L 5 X3,X4 W 15 L 8 X3,X6 W 15 L 12 X3,X1 WL 20 W 25 X2,X4 WL 10 L 8 X5,X6 WL 5 L 3 X6,X4 L 2 WL 3 Key values X1=20, X2=10, X3=25, X4=2, X5=5, X6=3. MAX= X3 MIN =X4 TABLE 5.3

17
EXPLANATION: 1.First column shows a sequence of comparison that may be carried out by some algorithm 2.Remaining columns shows the status and value assigned to the keys by the adversary. 3.Each row after first comparison contains only the entries relevant to current comparison. 4.In 5 th comparison when X3 and X1 are compared adversary increases the value of X3 because it is supposed to win. 5.In 8 th it changes the value of x4 and x6 consistent with its rules. 6. After first five comparison X3 has lost at least once so it is max. 7.After all comparison X4 is the only key that has never won so it is min. Result: In this example the algorithm did eight comparison. the worst case lower bound for six keys is (3/2) *6-2=7

18
Proof of theorem 5.1 We have to show that the adversary rule will force an algorithm to do at least 3n-2 comparison to get 2n-2 unit of information. Algorithm can get two units of information only when two keys have not been included in any previous comparison. Suppose n is even: Algorithm does n/2 comparison for unseen keys, so it can get at most n unit of information

19
Proof of theorem 5.1 cont. Algorithm needs n-2 additional unit of information so it must do at least n-2 more comparison Thus to get 2n-2 information it must do at least n/2+n-2=3n/2-2 comparisons. For odd n: Total no of comparison is 3n/2-3/2

20
Proof of theorem 5.1 cont. Algorithm needs n-2 additional unit of information so it must do at least n-2 more comparison Thus to get 2n-2 information it must do at least n/2+n-2=3n/2-2 comparisons. For odd n: Total no of comparison is 3n/2-3/2

21
Lower bound for Largest n Second Largest Any algorithm that works by comparing keys to find the second largest in a list of n keys must do at least n + log n – 2 comparisons. If we can show that `max’ participated in at least log n comparisons we are done because –Any algorithm that computes second largest must compute the largest. Why? To know that x is second largest, it must know that it is not the largest. That is it must loose to at least one comparison ( and in fact exactly one, since if it looses to two or more it is not the second largest.). And, when x looses to exactly one key, it knows that that key must be the largest. –If ‘max’ looses to only one key, we know that that key must be the second largest. But what if ‘max’ looses’ to more than one key. –So, any algorithm must do at least n-1 comparisons (where ‘max’ is compared with the rest of the keys ) and compare the “loosers to max” to get the second largest.

22
Adversary Assign weight w(x) to each key x. Initially w(x) = 1 for all x.

23
Adversary modifies the weights as per the following strategy. CaseAdversary response New weights w(x) > w(y)x > yw(x)←w(x) + w(y), w(y) ← 0 w(x) = w(y) > 0x > yw(x)←w(x) + w(y), w(y) ← 0 w(y) > w(x)y > xw(y)←w(x) + w(y), w(x) ← 0 w(x) = w(y) = 0consistent with previous results No change

24
Observations A key has lost a comparison iff its weight is zero.i.e. once a key has lost a comparison, its weight will never become non zero in future. Proof: Notice that once a key y has lost a comparison its weight becomes zero. Once its weight becomes it can never be compared with a key x whose weight w(x) is less than w(y). Hence w(y) never changes hereafter.

25
Observations The sum of the weights is always n. This is true initially and it is preserved when weights are updated. When the algorithm stops, only one key has a non-zero weight. Otherwise there would be at least two keys (say a and b) that never lost a comparison. The adversary can give arbitrarily high and distinct values to these two keys. –Now, if the algorithm declares a as largest and b as second largest, adversary can always choose the values the other way round and make the algorithm’s choice of largest and second largest incorrect.

26
Claim: In any algorithm to compute the largest, the largest must be compared with at least ceil(log n) keys in the worst case. Proof: Let x be the key that has non-zero weight when the algorithm stops. Then clearly x = largest. We’ll show that x has directly won over at least ceil(log n) distinct keys.

27
Let w k = w(x) be the weight of x after the kth comparison won by x against a previously undefeated key. Then, we’ll prove that w k ≤ 2w k-1 –If x has won against few previously defeated keys in between, its weight does not change. So, –w k = w k-1 + w(y) where y is the previously undefeated key –Clearly, w(y) ≤ w k-1 for else y wouldn’t loose to x. –Thus, w k ≤ 2w k-1 Let K be the number of comparisons x wins against previously undefeated keys, then n = w K ≤ 2 K w 0 = 2 K Thus K ≥ log n or K ≥ ceil(log n )

28
Assignment 5 Generate a worst case input for largest and second largest problem using the adversary strategy discussed here.

Similar presentations

OK

Analysis of Algorithms CS 477/677 Instructor: Monica Nicolescu.

Analysis of Algorithms CS 477/677 Instructor: Monica Nicolescu.

© 2019 SlidePlayer.com Inc.

All rights reserved.

To make this website work, we log user data and share it with processors. To use this website, you must agree to our Privacy Policy, including cookie policy.

Ads by Google