算法导论 第三版 第22章 答案 英

Chapter31Michelle Bodnar,Andrew LohrApril12,2016Exercise31.1-1By the given equation,we can write c=1·a+b,with0≥b<a.By the definition of remainders given just below the division theorem,this means that b is the remainder when c is divided by a,that is b=c mod a.Exercise31.1-2Suppose that there are onlyfinitely many primes p1,p2,...,p k.Then p= p1p2···p k+1isn’t prime,so there must be some p i which divides it.However, p i·(p1···p i−1p i+1···p k)<p and p·(p1···p i−1p i+1···p k+1)>p,so p i can’t divide p.Since this holds for any choice of i,we obtain a contradiction.Thus, there are infinitely many primes.Exercise31.1-3a|b means there exists k1∈Z so that k1a=b.b|c means there exists k2∈Z so that k2b=c.This means that(k1k2)a=c.Since the integers are a ring, k1k2∈Z,so,we have that a|c.Exercise31.1-4Let g=gcd(k,p).Then g|k and g|p.Since p is prime,g=p or g=1.Since 0<k<p,g<p.Thus,g=1.Exercise31.1-5By Theorem31.2,since gcd(a,n)=1,there exist integers p,q so that pa+qn=1,so,bpa+bqn=b.Since n|ab,there exists an integer k so that kn=ab.This means that knp+pqn=(k+q)pn=b.Since n divides the left hand side,it must divide the right hand side as well.Exercise31.1-61Observe that p k =p !k !(p −k )!=p (p −1)···(p −k +1)k !.Let q =(p −1)(p −2)···(p −k +1).Since p is prime,k !|p .However,we know that p k is an integer becauseit is also a counting formula.Thus,k !divides pq .By Corollary 31.5,k !|q .Write q =ck !.Then we have p k =pc ,which is divisible by p .By the binomial theorem and the fact that p | p k for 0<k <p ,(a +b )p =p k =0p k a k b p −k ≡a p +b p (mod p ).Exercise 31.1-7First,suppose that x =yb +(x mod b ),(x mod b )=za +((x mod b )mod a ),and ka =b .Then,we have x =yka +(x mod b )=(yk +z )a +((x mod b )mod a ).So,we have that x mod a =((x mod b )mod a ).For the second part of the problem,suppose that x mod b =y mod b .Then,by the first half of the problem,applied first to x and then to b,x mod a =(x mod b )mod a =(y mod b )mod a =y mod a .So,x ≡y mod a .Exercise 31.1-8We can test in time polynomial in βwhether or not a given β-bit number is a perfect k th power.Then,since two to the βth power is longer than the number we are given,we only need to test values of k between 2and β,thereby keeping the runtime polynomial in β.To check whether a given number n is a perfect k th power,we will be using a binary search like technique.That is,if we want to find the k-th root of a number,we initially know that it lies somewhere between 0and the number itself.We then look at the number of the current range of number under con-sideration,raise it to the k th power in time polynomial in β.We can do this by the method of repeated squaring discussed in section 31.6.Then,if we get a number larger than the given number when we perform repeated squaring,we know that the true k th root is in the lower half of the range in consideration,if it is equal,it is the midpoint,if larger,it is the upper half.Since each time,we are cutting down the range by a factor of two,and it is initially a range of length Θ(2β),the number of times that we need to raise a number the the k th power is Θ(β).Putting it all together,with the O (β3)time exponentiation,we get that the total runtime of this procedure is O (β5).Exercise 31.1-9For (31.6),we see that a and b in theorem 31.2which provides a characteri-zation of gcd appear symmetrically,so swapping the two won’t change anything.For (31.7),theorem 31.2tells us that gcd’s are defined in terms of integer linear combinations.If we had some integer linear combination involving a and2b,we can changed that into one involving(-a)and b by replacing the multiplier of a with its negation.For(31.8),by repeatedly applying(31.6)and(31.7),we can get this equality for all four possible cases based on the signs of both a and b.For(31.9),consider all integer linear combinations of a and0,the thing we multiply by will not affect thefinal linear combination,so,really we are just taking the set of all integer multiples of a andfinding the smallest element. We can never decrease the absolute value of a by multiplying by an integer (|ka|=|k||a|),so,the smallest element is just what is obtained by multiplying by1,which is|a|.For(31.10),again consider possible integer linear combinations na+mka, we can rewrite this as(n+km)a,so it has absolute value|n+km||a|.Since the first factor is an integer,we can’t have it with a value less than1and still have a positivefinal answer,this means that the smallest element is when thefirst factor is1,which is achievable by setting n=1,m=0.Exercise31.1-10Consider the prime factorization of each of a,b,and c,written as a= p1p2...p k where we allow repeats of primes.The gcd of b and c is just the product of all p i such that p i appears in both factorizations.If it appears multi-ple times,we include it as many times as it appears on the side with the fewest occurrences of p i.(Explicitly,see equation31.13on page934).To get the gcd of gcd(b,c)and a,we do this again.Thus,the left hand side is just equal to the intersection(with appropriate multiplicities)of the products of prime factors of a,b,and c.For the right hand side,we consider intersectingfirst the prime factors of a and b,and then the prime factors of c,but since intersections are associative,so is the gcd operator.Exercise31.1-11Suppose to a contradiction that we had two different prime decomposition. First,we know that the set of primes they both consist of are equal,because if there were any prime p in the symmetric difference,p would divide one of them but not the other.Suppose they are given by(e1,e2,...,e r)and(f1,f2,...,f r) and suppose that e i<f i for some position.Then,we either have that p e i+1i divides a or not.If it does,then the decomposition corresponding to{e i}is wrong because it doesn’t have enough factors of p i,otherwise,the one corre-sponding to{f i}is wrong because it has too many.Exercise31.1-12Standard long division runs in O(β2),and one can easily read offthe re-mainder term at the end.3Exercise 31.1-13First,we bump up the length of the original number until it is a power of two,this will not affect the asymptotics,and we just imagine padding it with zeroes on the most significant side,so it does not change its value as a number.We split the input binary integer,and split it into two segments,a less significant half and an more significant half m ,so that the input is equal to m 2β/2+ .Then,we recursively convert m and to decimal.Also,since we’ll need it later,we compute the decimal versions of all the values of 22i up to 2β.There are only lg(β)of these numbers,so,the straightforward approach only takes time O (lg 2(β))so will be overshadowed by the rest of the algorithm.Once we’ve done that,we evaluate m 2β/2+ ,which involves computing the product of two numbers and adding two numbers,so,we have the recurrenceT (β)=2T (β/2)+M (β/2)Since we have trouble separating M from linear by a n for some epsilon,the analysis gets easier if we just forget about the fact that the difficulty of the multiplication is going down in the subcases,this concession gets us the runtime that T (β)∈O (M (β)lg(β))by master theorem.Note that there is also a procedure to convert from binary to decimal that only takes time Θ(β),instead of the given algorithm which is Θ(M (β)lg(β))∈Ω(βlg(β))that is rooted in automata theory.We can construct a deterministic finite transducer between the two languages,then,since we only need to take as many steps as there are bits in the input,the runtime will be linear.We would have states to keep track of the carryover from each digit to the next.Exercise 31.2-1First,we show that the expression given in equation (31.13)is a common divisor.To see that we just notice thata =(r i =1p e i −min(e i ,f i )i )r i =1p min(e i ,f i )i andb =(r i =1p f i −min(e i ,f i )i )ri =1p min(e i ,f i )i Since none of the exponents showing up are negative,everything in sight is an integer.Now,we show that there is no larger common divisor.We will do this by showing that for each prime,the power can be no higher.Suppose we had some common divisor d of a and b .First note that d cannot have a prime factor that doesn’t appear in both a or b ,otherwise any integer times d would also have that factor,but being a common divisor means that we can write both a and b as an integer times d .So,there is some sequence {g i }so that d = r i =1p gi i .4Now,we claim that for every i,g i≤min(e i,f i).Suppose to a contradiction that there was some i so that g i>min(e i,f i).This means that d either has more factors of p i than a or than b.However,multiplying integers can’t cause the number of factors of each prime to decrease,so this is a contradiction,since we are claiming that d is a common divisor.Since the power of each prime in d is less than or equal to the power of each prime in c,we must have that d≤c. So,c is a GCD.Exercise31.2-2We’ll create a table similar to that offigure31.1:a b a/b d x y899493129-6114934061295-640687429-1587581291-1582922901290-2910Thus,(d,x,y)=(29,−6,11).Exercise31.2-3Let c be such that a=cn+(a mod n).If k=0,it is trivial,so suppose k< 0.Then,EUCLID(a+kn,n)goes to line3,so returns EUCLID(n,a mod n). Similarly,EUCLID(a,n)=EUCLID((a mod n)+cn,n)=EUCLID(n,a mod n).So,by correctness of the Euclidean algorithm,gcd(a+kn,n)=EUCLID(a+kn,n)=EUCLID(n,a mod n)=EUCLID(a,n)=gcd(a,n)Exercise31.2-4Algorithm1ITERATIVE-EUCLID(a,b)1:while b>0do2:(a,b)=(b,a mod b)3:end while4:return aExercise31.2-5We know that for all k,if b<F k+1<φk+1/√5,then it takes fewer than ksteps.If we let k=logφb+1,then,since b<φlogφb+2/√5=φ2√5·b,we havethat it only takes1+logφ(b)steps.5We can improve this bound to1+logφ(b/gcd(a,b)).This is because we knowthat the algorithm will terminate when it reaches gcd(a,b).We will emulate the proof of lemma31.10to show a slightly different claim that Euclid’s algorithm takes k recursive calls,then a≥gcd(a,b)F k+2and b≥gcd(a,b)F k+!.We will similarly do induction on k.If it takes one recursive call,and we have a>b,we have a≥2gcd(a,b)and b=gcd(a,b).Now,suppose it holds for k−1,we want to show it holds for k.Thefirst call that is made is of EUCLID(b,a mod b).Since this then only needsk−1recursive calls,we can apply the inductive hypothesis to get that b≥gcd(a,b)F k+1and a mod b≥gcd(a,b)F k.Since we had that a>b,we havethat a≥b+(a mod b)≥gcd(a,b)(F k+1+F k)=gcd(a,b)F k+2completing the induction.Since we have that we only need k steps so long as b<gcd(a,b)F k+1<gcd(a,b)φk+1.we have that logφ(b/gcd(a,b))<k+1.This is satisfied if we setk=1+logφ(b/gcd(a,b))Exercise31.2-6Since F k+1mod F k=F k−1we have gcd(F k+1,F k)=gcd(F k,F k−1).Sincegcd(2,1)=1we have that gcd(F k+1,F k)=1for all k.Moreover,since F k is increasing,we have F k+1/F k =1for all k.When we reach the base case ofthe recursive calls to EXTENDED-EUCLID,we return(1,1,0).The following returns are given by(d,x,y)=(d ,y ,x −y ).We will show that in general, EXTENDED-EUCLID(F k+1,F k)returns(1,(−1)k+1F k−2,(−1)k F k−1).We have already shown d is correct,and handled the base case.Now suppose the claim holds for k−1.Then EXTENDED-EUCLID(F k+1,F k)returns(d ,y ,x −y ) where d =1,y =(−1)k−1F k−2,x =(−1)k F k−3,so the algorithm returns(1,(−1)k−1F k−2,(−1)k F k−3−(−1)k−1F k−2)=(1,(−1)k+1F k−2,(−1)k(F k−3+F k−2)=(1,(−1)k+1F k−2,(−1)k F k−1) as desired.Exercise31.2-7To show it is independent of the order of its arguments,we prove the fol-lowing swap property,for all a,b,c,gcd(a,gcd(b,c))=gcd(b,gcd(a,c)).By applying these swaps in some order,we can obtain an arbitrary ordering on the variables(the permutation group is generated by the set of adjacent transposi-tions).Let a i be the power of the i th prime in the prime factor decompositionof a,similarly define b i and c i.Then,we have that6gcd(a,gcd(b,c))=i p min(a i,min(b i,c i)) i=i p min(a i,b i,c i) i=i p min(b i,min(a i,c i)) i=gcd(b,gcd(a,c))Tofind the integers{x i}as described in the problem,we use a similar approach as for EXTENDED-EUCLID.Exercise31.2-8From the gcd interpretation given in equation(31.13),it is clear that lcm(a1,a2)=a1·a2 gcd(a1,a2).More generally,lcm(a1,...,a n)=a1···a ngcd(···(gcd(gcd(a1,a2),a3),...),a n).Wecan compute the denominator recursively using the two-argument gcd opera-tion.The algorithm is given below,and runs in O(n)time.Algorithm2LCM(a1,...,a n)x=a1g=a1for i=2to n dox=x·a i)g=gcd(g,a i)end forreturn x/gExercise31.2-9For two numbers to be relatively prime,we need that the set of primes that occur in both of them are disjoint.Multiplying two numbers results in a number whose set of primes is the union of the two numbers multiplied. So,if we let p(n)denote the set of primes that divide n.By testing that gcd(n1n2,n3n4)=gcd(n1n3,n2n4)=1.We get that(p(n1)∪p(n2))∩(p(n3)∪(n4))=(p(n1)∪p(n3))∩(p(n2)∪(n4))=∅.Looking at thefirst equation,it gets us that p(n1)∩p(n3)=p(n1)∩p(n4)=p(n2)∩p(n3)=p(n2)∩p(n4)=∅.The second tells,among other things,that p(n1)∩p(n2)=p(n3)∩p(n4)=∅.This tells us that the sets of primes of any two elements are disjoint,so all elements are relatively prime.A way to view this that generalizes more nicely is to consider the complete graph on n vertices.Then,we select a partition of the vertices into two parts. Then,each of these parts corresponds to the product of all the numbers cor-responding to the vertices it contains.We then know that the numbers that7any pair of vertices that are in different parts of the partition correspond to will be relatively prime,because we can distribute the intersection across the union of all the prime sets in each partition.Since partitioning into two parts is equivalent to selecting a cut,the problem reduces to selecting lg(k)cuts of K n so that every edge is cut by one of the cuts.To do this,first cut the vertex set in as close to half as possible.Then,for each part,we recursively try to cut in in close to half,since the parts are disjoint,we can arbitrarily combine cuts on each of them into a single cut of the original graph.Since the number of time you need to divide n by two to get1is lg(n) ,we have that that is the number of times we need to take gcd.Exercise31.3-1+4012300123112302230133012·5123411234224133314244321Then,we can see that these are equivalent under the mappingα(0)=1,α(1)=3,α(2)=4,α(3)=2.Exercise31.3-2The subgroups of Z9and{0},{0,3,6},and Z9itself.The subgroups of Z∗13 are{1},{1,3,9},{1,3,4,9,10,12},{1,5,8,12},{1,12}and Z∗13itself. Exercise31.3-3Since S was afinite group,every element had afinite order,so,if a∈S , there is some number of times that you can add it to itself so that you get the identity,since adding any two things in S gets us something in S ,we have that S has the identity element.Associativity is for free because is is a property of the binary operation,no the space that the operation draws it’s arguments stly,we can see that it contains the inverse of every element,because we can just add the element to itself a number of times equal to one less than its order.Then,adding the element to that gets us the identity.Exercise31.3-48The only prime divisor of p e is p.From the definition of the Euler phi function,we haveφ(p e)=p e1−1p=p e−1(p−1).Exercise31.3-5To see this fact,we need to show that the given function is a bijection.Since the two sets have equal size,we only need to show that the function is onto. To see that it is onto,suppose we want an element that maps to x.Since Z∗n is afinite Abelian group by theorem31.13,we can take inverses,in particu-lar,there exists an element a−1so that aa−1=1mod n.This means that f a(a−1x)=aa−1x mod n=(aa−1mod n)(x mod n)=x mod n.Since we canfind an element that maps to any element of the range and the sizes of domain and range are the same,the function is a bijection.Any bijection from a set to itself is a permutation by definition.Exercise31.4-1First,we run extended Euclid on35,50and get the result(5,−7,10).Then, our initial solution is−7∗10/5=−14=36.Since d=5,we have four other solutions,corresponding to adding multiples of50/5=10.So,we also have that our entire solution set is x={6,16,26,36,46}.Exercise31.4-2If ax≡ay mod n then a(x−y)≡0mod n.Since gcd(a,n)=1,n doesn’t divide a unless n=1,in which case the claim is trivial.By Corollary31.5, since n divides a(x−y),n divides x−y.Thus,x≡y mod n.To see that the condition gcd(a,n)is necessary,let a=3,n=6,x=6,and y=2.Note that gcd(a,n)=gcd(3,6)=3.Then3·6≡3·2mod6,but6=2mod6.Exercise31.4-3it will work.It just changes the initial value,and so changes the order in which solutions are output by the program.Since the program outputs all val-ues of x that are congruent to x0mod n/b,if we shift the answer by a multiple of n/b by this modification,we will not be changing the set of solutions that the procedure outputs.Exercise31.4-4The claim is clear if a≡0since we can just factor out an x.For a=0, let g(x)=g0+g1x+...+g t−1x t−1.In order for f(x)to equal(x−a)g(x) we must have g0=f0(−a)−1,g i=(f i−g i−1)(−a)−1for1≤i≤t−1and9g t −1=f t .Since p is prime,Z ∗p ={1,2,...,p −1}so every element,includ-ing −a ,has a multiplicative inverse.It is easy to satisfy each of these equa-tions as we go,until we reach the last two,at which point we need to satisfy both g t −1=(f t −1−g t −2)(−a )−1and g t −1=f t .More compactly,we need f t =(f t −1−g t −2)(−a )−1.We will show that this happens when a is a zero of f .First,we’ll proceed inductively to show that for 0≤k ≤t −1we have a k +1g k =− k i =0f i a i .For the base case we have ag 0=−f 0,which holds.Assume the claim holds for k −1.Then we havea k +1g k =a k +1(f k −g k −1)(−a )−1=−a k f k +a k g k −1=−a k f k −k −1 i =0f i a i =ki =0f i a iwhich completes the induction step.Now we show that we can satisfy the equation given above.It will suffice to show that −a t f t =a t −1(f t −1−g t −2).a t −1(f t −1−g t −2)=a t −1f t −1−a t −1g t −2=a t −1f t −1+t −2 i =0f i a i =t −1i =0f i a i =−a t f twhere the second equality is justified by our earlier claim and the last equality is justified because a is a zero of f .Thus,we can find such a g .It is clear that a polynomial of degree 1can have at most 1distinct zero modulo p since the equation x =−a has at most 1solution by Corollary 31.25.Now suppose the claim holds for t >1.Let f be a degree t +1polynomial.If f has no zeros then we’re done.Otherwise,let a be a zero of f .Write f (x )=(x −a )g (x ).Then by the induction hypothesis,since g is of degree t ,g has at most t distinct zeros modulo p .The zeros of f are a and the zeros of g ,so f has at most t +1distinct zeros modulo p .Exercise 31.5-110These equations can be viewed as a single equation in the ring Z +5×Z 11+,in particular (x 1,x 2)=(4,5).This means that x needs to be the element in Z 55+that corresponds to the element (4,5).To do this,we use the process de-scribed in the proof of Theorem 31.27.We have m 1=11,m 2=5,c 1=11(11−1mod 5)=11,c 2=5(5−1mod 11)=45.This means that the corresponding solution is x =11·4+45·5mod 55=44+225mod 55=269mod 55=49mod 55.So,all numbers of the form 49+55k are a solution.Exercise 31.5-2Since 9·8·7=504,we’ll be working mod 504.We also have m 1=56,m 2=63,and m 3=72.We compute c 1=56(5)=280,c 2=63(7)=441,and c 3=72(4)=288.Thus,a =280+2(441)+3(288)mod 504=10mod 504.Thus,the desired integers x are of the form x =10+504k for k ∈Z .Exercise 31.5-3Suppose that x ≡a −1mod n .Also,x i ≡x mod n i and a i ≡a mod n i .What we then want to show is that x i ≡a −1i mod n i .That is,we want that a i x i ≡1mod n i .To see this,we just use equation 31.30.To get that ax mod n corresponds to (a 1x 1mod n 1,...,a k x k mod n k ).This means that 1corresponds to (1mod n 1,...,1mod n k ).This is telling us exactly what we needed,in particular,that a i x i ≡1mod n i .Exercise 31.5-4Let f (x )=f 0+f 1x +...+f d x d .Using the correspondence of Theorem 31.27,f (x )≡0mod n if and only if d i =0f i j x i j ≡0mod n j for j =1to k .The product formula arises by constructing a zero of f via choosing x 1,x 2,...,x k such that f (x j )≡0mod n j for each j ,then letting x be the number associated to (x 1,...,x k ).Exercise 31.6-1elementorder 112103545556107108109510211The smallest primitive root is2,and has the following values for ind11,2(x)x ind11,2(x)1102138425469778396105Exercise31.6-2To perform modular exponentiation by examining bits from right to left, we’ll keep track of the value of a2i as we go.See below for an implementation:Algorithm3MODULAR-EXPONENTIATION-R-to-L(a,b,n)c=0d=1s=alet b k,b k−1,...,b0 be the binary representation of bfor i=0to k doif b i==1thend=s·d mod nc=2i+cend ifs=s·s mod nend forreturn dExercise31.6-3Since we knowφ(n),we know that aφ(n)≡1mod n by Euler’s theorem. This tells us that a−1=aφ(n)−1because aa−1=≡aaφ(n)−1≡aφ(n)≡1mod n. Since when we multiply this expression times a,we get the identity,it is the inverse of a.We can then compute nφ(n)efficiently,sinceφ(n)<n,so can be represented without using more bits than was used to represent n.Exercise31.7-1For the secret key’s value of e we compute the inverse of d=3modφ(n)= 280.To do this,wefirst computeφ(280)=φ(23)φ(7)φ(5)=4·6·4=96.Since12any number raised to this will be one mod280,we will raise it to one less than this.So,we compute395≡3(32)47≡3(9(92)23)≡3(9(81(812)11))≡3(9(81(121(1212)5)))≡3(9(81(121(81(812)2≡3·9·81·121·81·81≡3·9·121≡187mod280Now that we know our value of e,we compute the encryption of M=100 by computing100187mod319,which comes out to an encrypted message of122 Exercise31.7-2We know ed=1modφ(n).Since d<φ(n)and e=3,we have3d−1= k(p−1)(q−1)for k=1or2.We have k=1if3d−1<n and k=2if 3d−1>n.Once we’ve determined k,p+q=n−(3d−1)/k+1,so we can now solve for p+q in time polynomial inβ.Replacing q−1by(p+q)−p−1 in our earlier equation lets us solve for p in time polynomial inβsince we need only perform addition,multiplication,and division on numbers bounded by n. Exercise31.7-3P A(M1)P A(M2)≡M e1M e2≡(M1M2)e≡P A(M1M2)mod nSo,if the attacker can correctly decode1100of the encrypted messages,hedoes the following.If the message is one that he can decrypt,he is happy,de-crypts it and stops.If it is not one that he can decrypt,then,he picks a random element in Z m,say x encrypts it with the public key,and multiplies that by theencrypted text,he then has a1100chance to be able to decrypt the new message.He keeps doing this until he can decrypt it.The number of steps needed follows a geometric distribution with a expected value of100.Once he’s stumbled upon one that he could decrypt,he multiplies by the inverses of all the elements that he multiplied by along the way.This recovers thefinal answer,and also can be done efficiently,since for every x,x n−2is x−1by Lagrange’s theorem.13Exercise31.8-1Suppose that we can write n= ki=1p e ii,then,by the Chinese remainder the-orem,we have that Z n∼=Z p e11×···×Z p e11.Since we had that n was not aprime power,we know that k≥2.This means that we can take the elementsx=(p e11−1,1,...,1)and y=(1,p e22−1,1,...,1).Since multiplication in theproduct ring is just coordinate wise,we have that the squares of both of theseelements is the all ones element in the product ring,which corresponds to1inZ n.Also,since the correspondence from the Chinese remainder theorem was a bijection,since x and y are distinct in the product ring,they correspond todistinct elements in Z n.Thus,by taking the elements corresponding to x and yunder the Chinese remainder theorem bijection,we have that we have found twosquareroots of1that are not the identity in Z n.Since there is only one trivialnon-identity squareroot in Z n,one of the two must be non-trivial.It turns outthat both are non-trivial,but that’s more than the problem is asking. Exercise31.8-2Let c=gcd(···(gcd(gcd(φ(p e11),φ(p e22)),φ(p e33)),...),φ(p e r r)).Then we haveλ(n)=φ(e e11)···φ(p e r r)/c=φ(n)/c.Since the lcm is an integer,λ(n)|φ(n).Suppose p is prime and p2|n.Sinceφ(p2)=p2(1−1p )=p2−p=p(p−1),we have that p must divideλ(n).however,since p divides n,it cannot divide n−1,so we cannot haveλ(n)|n−1.Now,suppose that is the product of fewer than3primes,that is n=pq for some two distinct primes p<q.Since both p and q were primes,λ(n)= lcm(φ(p),φ(q))=lcm(p−1,q−1).So,mod q−1,λ(n)≡0,however,since n−1=pq−1=(q−1)(p)+p−1,we have that n−1≡p−1mod q−1. Sinceλ(n)has a factor of q−1that n−1does not,meaning thatλ(n)|n−1.Exercise31.8-3First,we prove the following lemma.For any integers a,b,n,gcd(a,n)·gcd(b,n)≥gcd(ab,n).Let{p i}be an enumeration of the primes,then,by Theorem31.8,there is exactly one set of powers of these primes so that a=i p a ii,b=ip b ii,and n=ip n ii.gcd(a,n)=ip min(a i,n i)igcd(b,n)=ip min(b i,n i)igcd(ab,n)=ip min(a i+b i,n i)i14We combine thefirst two equations to get:gcd(a,n)·gcd(b,n)=ip min(a i,n i)i·ip min(b i,n i)i=i p min(a i,n i)+min(b i,n i) i≥i p min(a i+b i,n i) i=gcd(ab,n)Since x is a non-trivial squareroot,we have that x2≡1mod n,but x=1 and x=n−1.Now,we consider the value of gcd(x2−1,n).By theorem31.9, this is equal to gcd(n,x2−1mod n)=gcd(n,1−1)=gcd(n,0)=n.So,we can then look at the factorization of x2−1=(x+1)(x−1)to get thatgcd(x+1,n)gcd(x−1,n)≥nHowever,we know that since x is a nontrivial squareroot,we know that 1<x<n−1so,neither of the factors on the right can be equal to n.This means that both of the factors on the right must be nontrivial.Exercise31.9-1The Pollard-Rho algorithm wouldfirst detect the factor of73when it con-siders the element84,when we have x12because we then notice that gcd(814−84,1387)=73.Exercise31.9-2Create an array A of length n.For each x i,if x i=j,store i in A[j].If j is thefirst position of A which must have its entry rewritten,set t to be the entry originally stored in that spot.Then count how many additional x i’s must be computed until x i=j again.This is the value of u.The running time isΘ(t+u).Exercise31.9-3Assuming that p e divides n,by the same analysis as sin the chapter,it will take timeΘ(p e/2).To see this,we look at what is happening to the sequence mod p n.15x i +1=x i +1mod p e =f n (x i )mod p e=((x 2−1)mod n )mod p e =(x 2−1)mod p e=(x i )2−1mod p e =f p e (x i )So,we again are having the birthday paradox going on,but,instead of hop-ing for a repeat from a set of size p ,we are looking at all the equivalence classes mod p e which has size p e ,so,we have that the expected number of steps be-fore gettinga repeat in that size set is just the squareroot of its size,which is Θ(√p e )=Θ(p e/2).Exercise 31.9-4Problem 31-1a.If a and b are both even,then we can write them as a =2(a/2)and b =2(b/2)where both factors in each are integers.This means that,by Corollary 31.4,gcd(a,b )=2gcd(a/2,b/2).b.If a is odd,and b is even,then we can write b =2(b/2),where b/2is an integer,so,since we know that 2does not divide a ,the factor of two that is in b cannot be part of the gcd of the two numbers.This means that we have gcd(a,b )=gcd(a,b/2).More formally,suppose that d =gcd(a,b ).Since d is a common divisor,it must divide a ,and so,it must not have any even factors.This means that it also divides a and b/2.This means that gcd(a,b )≤gcd(a,b/2).To see the reverse,suppose that d =gcd(a,b/2),then it is also a divisor of a and b ,since we can just double whatever we need to multiply it by to get b/2.Since we have inequalities both ways,we have equality.c.If a and b are both odd,then,first,in analoge to theorem 31.9,we show that gcd(a,b )=gcd(a −b,b ).Let d and d be the gcd’s on the left and right respectively.Then,we have that there exists n 1,n 2so that n 1a +n 2b =d ,but then,we can rewrite to get n 1(a −b )+(n 1+n 2)b =d .This getsus d ≥d .To see the reverse,let n 1,n 2so that n 1(a −b )+n 2b =d .We rewrite to get n 1a +(n 2−n 1)b =d ,so we have d ≥d .This meansthat gcd(a,b )=gcd(a −b,b )=gcd(b,a −b ).From there,we fall into the case of part b.This is because the first argument is odd,and the second is the difference of two odd numbers,hence is even.This means we can halve the second argument without changing the quantity.So,gcd(a,b )=gcd(b,(a −b )/2)=gcd((a −b )/2,b ).16。

算法导论（第三版）－复习－第六部分图论22-26［转］22习题22.1-5 有向图G(V, E)的平⽅图。

链表表⽰时，对每结点u的Adj[u]中所有v加⼊队列，后边出队边将Adj[v]加⼊Adj[u]中。

矩阵表⽰时，若w[i, j]、w[j, k]同时为1则将w[i, k]置1.习题22.1-6 O(V)的时间寻找通⽤汇点。

汇点的特征是邻接矩阵的第j列除[j, j]外所有元素为1. 可将每⾏调整[j ,j]后作为⼀个整数，所有整数与运算，为1的位是汇点。

习题22.1-7 有向⽆环图的关联矩阵B，BB’每个元素C[i, j]=∑B[i, k]*B’[k, j]=∑B[i, k]*B[j, k]，即同时进i, j两结点与同时出i, j的结点总数-⼀进⼀出i, j两结点的结点总数。

习题22.2-7 类似BFS，d mod2为0则标为B（娃娃脸），d mod2为1则标为H（⾼跟鞋）。

但若有边连接相同类的结点，则⽆法划分。

wrestler(G){for each u in G{(u,v)=Adj[u];if(v.mark==u.mark){throw error;}if(v.d==NIL) {v.d=u.d+1; v.mark=v.d mod 2;}}}习题22.2-8 任意点之间的最短路径。

重复的Dijktra算法或Floyd-Warshall算法习题22.2-9 ⽆向图扩展为有向图。

问题变成要遍历所有边⼀次。

访问结点u时，将u的⼦结点v的其他边都可视为⼦集v，问题等价于u到v，访问v的集合，v到u。

u标为visiting⼊列，然后访问v，v标为visiting⼊列，然后访问v的后继结点，访问过的边标为visited，返回到visiting的点时，如果该点所有连接的边都标为visited只剩⼀条返回上级的边，则返回上级结点并将点标为visited，v出列，访问u的其他⼦结点，最终u出列。

全部结点出列后达到遍历所有边⼀次。

上机实验 书上 121 页 5。

2 5。

3 书上 151 6。

1 6。

3 6。

6 他说搞懂这几题和实验就没问题了4.2 在下列情况下求解递归关系式当① n=2k g(n)= O(1) 和 f(n)= O(n) ； ②n=2k g(n)= 0(1)和 f(n)= 0(1)。

kk-1kk-2k-1k解: T(n)=T(2 k )=2T(2 k-1)+f(2 k )=2(2 T(2 k-2)+f(2 k-1)) +f(2 k )=2 2T(2k-2)+21 f(2 k-1)+ f(2 k )不妨设 g(n)=a ，f(n)=bn ，a ，b 为正常数。

则T(n)=T(2 k )= 2 k a+ 2 k-1*2b+2k-2*22b+…+2°*2k b =2k a+kb2k=an+bnlog 2n= 0(nlog 2n)② 当 g(n)= 0(1)和 f(n)= 0(1)时， 不妨设 g(n)=c ，f(n)=d ，c ，d 为正常数。

则 T(n)=T(2 k )=c2k + 2 k-1d+2k-2d+…+2°d=c2k +d(2k -1) =(c+d)n-d= 0(n) 4.3 根据教材中所给出的二分检索策略，写一个二分检索的递归过程。

Procedure BINSRCH(A,low, high, x, j) integer mid if low < high the n mid J (low high)/2 if x=A(mid) then jJ mid; endifif x>A(mid) then BINSRCH(A, mid+1, high, x, j); endif if x<A(mid) thenBINSRCH(A, low, mid-1, x, j); endif else j J 0; endif end BINSRCH4.5 作一个“三分”检索算法。

第课答案一、选择题1、A2、A3、B4、C5、B6、D7、C8、D9、D10、B11、A12、A13、A二、填空题1、定义的位子，存储类型，存储方式。

2、整形，int3、静态局部变量定义的复合语句或函数体内，整个程序运行期内。

4、地址传递，值传递5、整个函数体内，函数体内定义的局部6、return，void7、数组名、地址，指针变量。

8、地址传递9、值传递10、sort（a,7），float *p, int n ，p[k]<p[j] ) ，if(k != i)11、*min = *p，t>*max三、程序执行题1、输出：-12、输出：fedcba3、输出：5 6，7 7，12 64、输出：4,2,8,95、输出：122012年11月15号热点作文6Directions: For this part, you are allowed 30 minutes to write a composition on the topic Self help Traveling of Coll e ge Students. You should write at least 150 words, and base your composition on the outline (given in Chinese) below:1）大学生出去旅行经常会选择“自助游”2）分析大学生选择“自助游”的原因3）你的看法【思路点拨】本题属于提纲式文字命题。

提纲第1点指出一种现象，提纲第2点要求分析这种现象产生的原因，提纲第3点要求谈谈“我”对该现象的看法，由此可判断本文应为现象解释型作文。

根据所给提纲，本文应包含以下内容：简单说明何谓“自助游”，描述大学生热衷于“自助游”的现象；分析大学生选择“自助游”主要原因；阐述“我”对“自助游”的看法。

【参考范文】Self-help Traveling of College StudentsSo called self-help traveling refers that travelers themselves arrange travel route, travel time, and all the other matters during travel, without any guide and team leader. Nowadays this kind of traveling model is gaining more and more popularity among college students. According to the survey, over 80% of college students prefer self-help traveling to following a tour group.Why are college students so fond of self-help traveling? Above all, self-help traveling gives travelers more freedom and space. College students don’t like being restricted. They want to arrange their travel as they wish. Moreover, self-help traveling provides college students a good chance to improve their adaptability and viability. Besides, the expenses inself-help traveling are controlled by travelers themselves. It is a good choice for those college students who have not much money for their disposal.As a college student, I enjoy self-help traveling very much, and I have benefited a lot from it. For one thing, I have appreciated many amazing scenery that those travelers who follow tour groups can not. For another, self-help travel helps me learn how to deal with people better.热点作文7Directions: For this part, you are allowed 30 minutes to write a composition on the topic Credit Cards on Campus. You should write at least 150 words, and base your composition on the outline (given in Chinese) below:1）近年来越来越多的大学生开始使用信用卡2）分析产生该现象的原因3）针对大学生使用信用卡提出你的建议【思路点拨】本题属于提纲式文字命题。

Chapter16Michelle Bodnar,Andrew LohrApril12,2016Exercise16.1-1The given algorithm would just stupidly compute the minimum of the O(n) numbers or return zero depending on the size of S ij.There are a possible number of subproblems that is O(n2)since we are selecting i and j so that1≤i≤j≤n.So,the runtime would be O(n3).Exercise16.1-2This becomes exactly the same as the original problem if we imagine time running in reverse,so it produces an optimal solution for essentially the same reasons.It is greedy because we make the best looking choice at each step.Exercise16.1-3As a counterexample to the optimality of greedily selecting the shortest, suppose our activity times are{(1,9),(8,11),(10,20)}then,picking the shortestfirst,we have to eliminate the other two,where if we picked the other two instead,we would have two tasks not one.As a counterexample to the optimality of greedily selecting the task that conflicts with the fewest remaining activities,suppose the activity times are {(−1,1),(2,5),(0,3),(0,3),(0,3),(4,7),(6,9),(8,11),(8,11),(8,11),(10,12)}.Then, by this greedy strategy,we wouldfirst pick(4,7)since it only has a two con-flicts.However,doing so would mean that we would not be able to pick the only optimal solution of(−1,1),(2,5),(6,9),(10,12).As a counterexample to the optimality of greedily selecting the earliest start times,suppose our activity times are{(1,10),(2,3),(4,5)}.If we pick the ear-liest start time,we will only have a single activity,(1,10),whereas the optimal solution would be to pick the two other activities.Exercise16.1-4Maintain a set of free(but already used)lecture halls F and currently busy lecture halls B.Sort the classes by start time.For each new start time which you encounter,remove a lecture hall from F,schedule the class in that room,1and add the lecture hall to B.If F is empty,add a new,unused lecture hall to F.When a classfinishes,remove its lecture hall from B and add it to F. Why this is optimal:Suppose we have just started using the m th lecture hall for thefirst time.This only happens when ever classroom ever used before is in B.But this means that there are m classes occurring simultaneously,so it is necessary to have m distinct lecture halls in use.Exercise16.1-5Run a dynamic programming solution based offof the equation(16.2)where the second case has“1”replaced with“v k”.Since the subproblems are still indexed by a pair of activities,and each calculation requires taking the minimum over some set of size≤|S ij|∈O(n).The total runtime is bounded by O(n3). Exercise16.2-1A optimal solution to the fractional knapsack is one that has the highest total value density.Since we are always adding as much of the highest value density we can,we are going to end up with the highest total value density. Suppose that we had some other solution that used some amount of the lower value density object,we could substitute in some of the higher value density object meaning our original solution coud not of been optimal.Exercise16.2-2Suppose we know that a particular item of weight w is in the solution.Then we must solve the subproblem on n−1items with maximum weight W−w. Thus,to take a bottom-up approach we must solve the0-1knapsack problem for all items and possible weights smaller than W.We’ll build an n+1by W+1table of values where the rows are indexed by item and the columns are indexed by total weight.(Thefirst row and column of the table will be a dummy row).For row i column j,we decide whether or not it would be advantageous to include item i in the knapsack by comparing the total value of of a knapsack including items1through i−1with max weight j,and the total value of including items1through i−1with max weight j−i.weight and also item i.To solve the problem,we simply examine the n,W entry of the table to determine the maximum value we can achieve.To read offthe items we include, start with entry n,W.In general,proceed as follows:if entry i,j equals entry i−1,j,don’t include item i,and examine entry i−1,j next.If entry i,j doesn’t equal entry i−1,j,include item i and examine entry i−1,j−i.weight next. See algorithm below for construction of table:Exercise16.2-3At each step just pick the lightest(and most valuable)item that you can pick.To see this solution is optimal,suppose that there were some item j that we included but some smaller,more valuable item i that we didn’t.Then,we could replace the item j in our knapsack with the item i.it will definitelyfit2Algorithm10-1Knapsack(n,W)1:Initialize an n+1by W+1table K2:for j=1to W do3:K[0,j]=04:end for5:for i=1to n do6:K[i,0]=07:end for8:for i=1to n do9:for j=1to W do10:if j<i.weight then11:K[i,j]=K[i−1,j]12:end if13:K[i,j]=max(K[i−1,j],K[i−1,j−i.weight]+i.value)14:end for15:end forbecause i is lighter,and it will also increase the total value because i is more valuable.Exercise16.2-4The greedy solution solves this problem optimally,where we maximize dis-tance we can cover from a particular point such that there still exists a place to get water before we run out.Thefirst stop is at the furthest point from the starting position which is less than or equal to m miles away.The problem exhibits optimal substructure,since once we have chosen afirst stopping point p,we solve the subproblem assuming we are starting at bining these two plans yields an optimal solution for the usual cut-and-paste reasons.Now we must show that this greedy approach in fact yields afirst stopping point which is contained in some optimal solution.Let O be any optimal solution which has the professor stop at positions o1,o2,...,o k.Let g1denote the furthest stopping point we can reach from the starting point.Then we may replace o1by g2to create a modified solution G,since o2−o1<o2−g1.In other words,we can actually make it to the positions in G without running out of water.Since G has the same number of stops,we conclude that g1is contained in some optimal solution.Therefore the greedy strategy works.Exercise16.2-5Consider the leftmost interval.It will do no good if it extends any further left than the leftmost point,however,we know that it must contain the leftmost point.So,we know that it’s left hand side is exactly the leftmost point.So,we just remove any point that is within a unit distance of the left most point since3they are contained in this single interval.Then,we just repeat until all points are covered.Since at each step there is a clearly optimal choice for where to put the leftmost interval,thisfinal solution is optimal.Exercise16.2-6First compute the value of each item,defined to be it’s worth divided by its weight.We use a recursive approach as follows:Find the item of median value, which can be done in linear time as shown in chapter9.Then sum the weights of all items whose value exceeds the median and call it M.If M exceeds W then we know that the solution to the fractional knapsack problem lies in taking items from among this collection.In other words,we’re now solving the frac-tional knapsack problem on input of size n/2.On the other hand,if the weight doesn’t exceed W,then we must solve the fractional knapsack problem on the input of n/2low-value items,with maximum weight W−M.Let T(n)denote the runtime of the algorithm.Since we can solve the problem when there is only one item in constant time,the recursion for the runtime is T(n)=T(n/2)+cn and T(1)=d,which gives runtime of O(n).Exercise16.2-7Since an identical permutation of both sets doesn’t affect this product,sup-pose that A is sorted in ascending order.Then,we will prove that the product is maximized when B is also sorted in ascending order.To see this,suppose not,that is,there is some i<j so that a i<a j and b i>b j.Then,consideronly the contribution to the product from the indices i and j.That is,a b ii a b j j,then,if we were to swap the order of b1and b j,we would have that contributionbe a b ji a b ij.we can see that this is larger than the previous expression becauseit differs by a factor of(a ja i )b i−b j which is bigger than one.So,we couldn’t ofmaximized the product with this ordering on B.Exercise16.3-1If we have that x.freq=b.freq,then we know that b is tied for lowest frequency.In particular,it means that there are at least two things with lowest frequency,so y.freq=x.freq.Also,since x.freq≤a.freq≤b.freq=x.freq, we must have a.freq=x.freq.Exercise16.3-2Let T be a binary tree corresponding to an optimal prefix code and suppose that T is not full.Let node n have a single child x.Let T be the tree obtained by removing n and replacing it by x.Let m be a leaf node which is a descendant of x.Then we have4cost(T )≤c∈C\{m}c.freq·d T(c)+m.freq(d T(m)−1)<c∈Cc.freq·d T(c)=cost(T)which contradicts the fact that T was optimal.Therefore every binary tree corresponding to an optimal prefix code is full.Exercise16.3-3An optimal huffman code would be00000001→a0000001→b000001→c00001→d0001→e001→f01→g1→hThis generalizes to having thefirst n Fibonacci numbers as the frequencies in that the n th most frequent letter has codeword0n−11.To see this holds,we will prove the recurrencen−1i=0F(i)=F(n+1)−1This will show that we should join together the letter with frequency F(n)with the result of joining together the letters with smaller frequencies.We will prove it by induction.For n=1is is trivial to check.Now,suppose that we have n−1≥1,then,F(n+1)−1=F(n)+F(n−1)−1=F(n−1)+n−2i=0F(i)=n−1i=0F(i)See also Lemma19.2.Exercise16.3-4Let x be a leaf node.Then x.freq is added to the cost of each internal node which is an ancestor of x exactly once,so its total contribution to the new way of computing cost is x.freq·d T(x),which is the same as its old contribution. Therefore the two ways of computing cost are equivalent.5Exercise16.3-5We construct this codeword with monotonically increasing lengths by always resolving ties in terms of which two nodes to join together by joining together those with the two latest occurring earliest elements.We will show that the ending codeword has that the least frequent words are all having longer code-words.Suppose to a contradiction that there were two words,w1and w2so that w1appears more frequently,but has a longer codeword.This means that it was involved in more merge operation than w2was.However,since we are always merging together the two sets of words with the lowest combined frequency,this would contradict the fact that w1has a higher frequency than w2.Exercise16.3-6First observe that any full binary tree has exactly2n−1nodes.We can encode the structure of our full binary tree by performing a preorder traversal of T.For each node that we record in the traversal,write a0if it is an internal node and a1if it is a leaf node.Since we know the tree to be full,this uniquely determines its structure.Next,note that we can encode any character of C in lg n bits.Since there are n characters,we can encode them in order of appearance in our preorder traversal using n lg n bits.Exercise16.3-7Instead of grouping together the two with lowest frequency into pairs that have the smallest total frequency,we will group together the three with lowest frequency in order to have afinal result that is a ternary tree.The analysis of optimality is almost identical to the binary case.We are placing the symbols of lowest frequency lower down in thefinal tree and so they will have longer codewords than the more frequently occurring symbolsExercise16.3-8For any2characters,the sum of their frequencies exceeds the frequency of any other character,so initially Huffman coding makes128small trees with2 leaves each.At the next stage,no internal node has a label which is more than twice that of any other,so we are in the same setup as before.Continuing in this fashion,Huffman coding builds a complete binary tree of height lg(256)=8, which is no more efficient than ordinary8-bit length codes.Exercise16.3-9If every possible character is equally likely,then,when constructing the Huff-man code,we will end up with a complete binary tree of depth7.This means that every character,regardless of what it is will be represented using7bits. This is exactly as many bits as was originally used to represent those characters, so the total length of thefile will not decrease at all.6Exercise16.4-1Thefirst condition that S is afinite set is a given.To prove the second condition we assume that k≥0,this gets us that I k is nonempty.Also,to prove the hereditary property,suppose A∈I k this means that|A|≤k.Then, if B⊆A,this means that|B|≤|A|≤k,so B∈I stly,we prove the exchange property by letting A,B∈I k be such that|A|<|B|.Then,we can pick any element x∈B\A,then,|A∪{x}|=|A|+1≤|B|≤k,so,we can extend A to A∪{x}∈I k.Exercise16.4-2Let c1,...,c m be the columns of T.Suppose C={c i1,...,c ik}is depen-dent.Then there exist scalars d1,...,d k not all zero such that kj=1d j c ij=0.By adding columns to C and assigning them to have coefficient0in the sum, we see that any superset of C is also dependent.By contrapositive,any subset of an independent set must be independent.Now suppose that A and B are two independent sets of columns with|A|>|B|.If we couldn’t add any col-umn of A to be whilst preserving independence then it must be the case that every element of A is a linear combination of elements of B.But this implies that B spans a|A|-dimensional space,which is impossible.Therefore our in-dependence system must satisfy the exchange property,so it is in fact a matroid.Exercise16.4-3Condition one of being a matroid is still satisfied because the base set hasn’t changed.Next we show that I is nonempty.Let A be any maximal element of I then,we have that S−A∈I because S−(S−A)=A⊆A which is maximal in I.Next we show the hereditary property,suppose that B⊆A∈I ,then, there exists some A ∈I so that S−A⊆A ,however,S−B⊇S−A⊆A so B∈I .Lastly we prove the exchange property.That is,if we have B,A∈I and |B|<|A|we canfind an element x in A−B to add to B so that it stays independent.We will split into two cases.Ourfirst case is that|A|=|B|+1.We clearly need to select x to be the single element in A−B.Since S−B contains a maximal independent set Our second case is if thefirst case does not hold.Let C be a maximal inde-pendent set of I contained in S−A.Pick an aribitrary set of size|C|−1from some maximal independent set contained in S−B,call it D.Since D is a subset of a maximal independent set,it is also independent,and so,by the exchange property,there is some y∈C−D so that D∪{y}is a maximal independent set in I.Then,we select x to be any element other than y in A−B.Then, S−(B∪{x})will still contain D∪{y}.This means that B∪{x}is independent in(I)7Exercise16.4-4Suppose X⊂Y and Y∈I.Then(X∩S i)⊂(Y∩S i)for all i,so |X∩S i|≤|Y∩S i|≤1for all1≤i≤k.Therefore M is closed under inclusion.Now Let A,B∈I with|A|=|B|+1.Then there must exist some j such that|A∩S j|=1but B∩S j|=0.Let a=A∩S j.Then a/∈B and |(B∪{a})∩S j|=1.Since|(B∪{a})∩S i|=|B∩S i|for all i=j,we must have B∪{a}∈I.Therefore M is a matroid.Exercise16.4-5Suppose that W is the largest weight that any one element takes.Then, define the new weight function w2(x)=1+W−w(x).This then assigns a strictly positive weight,and we will show that any independent set that that has maximum weight with respect to w2will have minimum weight with respect to w.Recall Theorem16.6since we will be using it,suppose that for our matriod,all maximal independent sets have size S.Then,suppose M1and M2 are maximal independent sets so that M1is maximal with respect to w2and M2is minimal with respect to w.Then,we need to show that w(M1)=w(M2). Suppose not to achieve a contradiction,then,by minimality of M2,w(M1)> w(M2).Rewriting both sides in terms of w2,we have w2(M2)−(1+W)S> w2(M1)−(1+W)S,so,w2(M2)>w2(M1).This however contradicts maximality of M1with respect to w2.So,we must have that w(M1)=w(M2).So,a maximal independent set that has the largest weight with respect to w2also has the smallest weight with respect to w.Exercise16.5-1With the requested substitution,the instance of the problem becomesa i1234567d i4243146w i10203040506070We begin by just greedily constructing the matroid,adding the most costly to leave incomplete tasksfirst.So,we add tasks7,6,5,4,3.Then,in order to schedule tasks1or2we need to leave incomplete more important tasks.So, ourfinal schedule is 5,3,4,6,7,1,2 to have a total penalty of only w1+w2=30.Exercise16.5-2Create an array B of length n containing zeros in each entry.For each ele-ment a∈A,add1to B[a.deadline].If B[a.deadline]>a.deadline,return that the set is not independent.Otherwise,continue.If successfully examine every element of A,return that the set is independent.8Problem16-1a.Always give the highest denomination coin that you can without going over.Then,repeat this process until the amount of remaining change drops to0.b.Given an optimal solution(x0,x1,...,x k)where x i indicates the number ofcoins of denomination c i.We willfirst show that we must have x i<c for every i<k.Suppose that we had some x i≥c,then,we could decrease x i by c and increase x i+1by1.This collection of coins has the same value and has c−1fewer coins,so the original solution must of been non-optimal.This configuration of coins is exactly the same as you would get if you kept greedily picking the largest coin possible.This is because to get a total value of V,you would pick x k= V c−k and for i<k,x i (V modc i+1)c−i .This is the only solution that satisfies the property that there aren’t more than c of any but the largest denomination because the coin amounts are a base c representation of V modc k.c.Let the coin denominations be{1,3,4},and the value to make change for be6.The greedy solution would result in the collection of coins{1,1,4}butthe optimal solution would be{3,3}.d.See algorithm MAKE-CHANGE(S,v)which does a dynamic programmingsolution.Since thefirst forloop runs n times,and the inner for loop runs k times,and the later while loop runs at most n times,the total running time is O(nk).Problem16-2a.Order the tasks by processing time from smallest to largest and run them inthat order.To see that this greedy solution is optimal,first observe that the problem exhibits optimal substructure:if we run thefirst task in an optimal solution,then we obtain an optimal solution by running the remaining tasks in a way which minimizes the average completion time.Let O be an optimal solution.Let a be the task which has the smallest processing time and let b be thefirst task run in O.Let G be the solution obtained by switching the order in which we run a and b in O.This amounts reducing the completion times of a and the completion times of all tasks in G between a and b by the difference in processing times of a and b.Since all other completion times remain the same,the average completion time of G is less than or equal to the average completion time of O,proving that the greedy solution gives an optimal solution.This has runtime O(n lg n)because we mustfirst sort the elements.b.Without loss of generality we my assume that every task is a unit time task.Apply the same strategy as in part(a),except this time if a task which we9Algorithm2MAKE-CHANGE(S,v)Let numcoins and coin be empty arrays of length v,and any any attempt to access them at indices in the range−max(S),−1should return∞for i from1to v dobestcoin=nilbestnum=∞for c in S doif numcoins[i−c]+1<bestnum thenbestnum=numcoins[i-c]bestcoin=cend ifend fornumcoins[i]=bestnumcoin[i]=bestcoinend forlet change be an empty setiter=vwhile iter>0doadd coin[iter]to changeiter=iter−coin[iter]end whilereturn changewould like to add next to the schedule isn’t allowed to run yet,we must skip over it.Since there could be many tasks of short processing time which have late release time,the runtime becomes O(n2)since we might have to spend O(n)time deciding which task to add next at each step.Problem16-3a.First,suppose that a set of columns is not linearly independent over F2then,there is some subset of those columns,say S so that a linear combination of S is0.However,over F2,since the only two elements are1and0,a linear combination is a sum over some subset.Suppose that this subset is S ,note that it has to be nonempty because of linear dependence.Now,consider the set of edges that these columns correspond to.Since the columns had their total incidence with each vertex0in F2,it is even.So,if we consider the subgraph on these edges,then every vertex has a even degree.Also,since our S was nonempty,some component has an edge.Restrict our attention to any such component.Since this component is connected and has all even vertex degrees,it contains an Euler Circuit,which is a cycle.Now,suppose that our graph had some subset of edges which was a cycle.Then,the degree of any vertex with respect to this set of edges is even,so,10when we add the corresponding columns,we will get a zero column in F2.Since sets of linear independent columns form a matroid,by problem16.4-2, the acyclic sets of edges form a matroid as well.b.One simple approach is to take the highest weight edge that doesn’t completea cycle.Another way to phrase this is by running Kruskal’s algorithm(seeChapter23)on the graph with negated edge weights.c.Consider the digraph on[3]with the edges(1,2),(2,1),(2,3),(3,2),(3,1)where(u,v)indicates there is an edge from u to v.Then,consider the two acyclic subsets of edges B=(3,1),(3,2),(2,1)and A=(1,2),(2,3).Then, adding any edge in B−A to A will create a cycle.So,the exchange property is violated.d.Suppose that the graph contained a directed cycle consisting of edges corre-sponding to columns S.Then,since each vertex that is involved in this cycle has exactly as many edges going out of it as going into it,the rows corre-sponding to each vertex will add up to zero,since the outgoing edges count negative and the incoming vertices count positive.This means that the sum of the columns in S is zero,so,the columns were not linearly independent.e.There is not a perfect correspondence because we didn’t show that not con-taining a directed cycle means that the columns are linearly independent, so there is not perfect correspondence between these sets of independent columns(which we know to be a matriod)and the acyclic sets of edges (which we know not to be a matroid).Problem16-4a.Let O be an optimal solution.If a j is scheduled before its deadline,we canalways swap it with whichever activity is scheduled at its deadline without changing the penalty.If it is scheduled after its deadline but a j.deadline≤j then there must exist a task from among thefirst j with penalty less than that of a j.We can then swap a j with this task to reduce the overall penalty incurred.Since O is optimal,this can’t happen.Finally,if a j is scheduled after its deadline and a j.deadline>j we can swap a j with any other late task without increasing the penalty incurred.Since the problem exhibits the greedy choice property as well,this greedy strategy always yields on optimal solution.b.Assume that MAKE-SET(x)returns a pointer to the element x which isnow it its own set.Our disjoint sets will be collections of elements which have been scheduled at contiguous times.We’ll use this structure to quickly find the next available time to schedule a task.Store attributes x.low and x.high at the representative x of each disjoint set.This will give the earliest and latest time of a scheduled task in the block.Assume that UNION(x,y)11maintains this attribute.This can be done in constant time,so it won’t af-fect the asymptotics.Note that the attribute is well-defined under the union operation because we only union two blocks if they are contiguous.Without loss of generality we may assume that task a1has the greatest penalty,task a2has the second greatest penalty,and so on,and they are given to us in the form of an array A where A[i]=a i.We will maintain an array D such that D[i]contains a pointer to the task with deadline i.We may assume that the size of D is at most n,since a task with deadline later than n can’t possibly be scheduled on time.There are at most3n total MAKE-SET,UNION,and FIND-SET operations,each of which occur at most n times,so by Theorem21.14the runtime is O(nα(n)).Algorithm3SCHEDULING-VARIATIONS(A)1:Initialize an array D of size n.2:for i=1to n do3:a i.time=a i.deadline4:if D[a i.deadline]=NIL then5:y=FIND-SET(D[a i.deadline])6:a i.time=y.low−17:end if8:x=MAKE-SET(a i)9:D[a i.time]=x10:x.low=x.high=a i.time11:if D[a i.time−1]=NIL then12:UNION(D[a i.time−1],D[a i.time])13:end if14:if D[a i.time+1]=NIL then15:UNION(D[a i.time],D[a i.time+1])16:end if17:end forProblem16-5a.Suppose there are m distinct elements that could be requested.There may besome room for improvement in terms of keeping track of the furthest in future element at each position.If you maintain a(double circular)linked list witha node for each possible cache element and an array so that in index i thereis a pointer corresponding to the node in the linked list corresponding to the possible cache request i.Then,starting with the elements in an arbitrary order,process the sequence r1,...,r n from right to left.Upon processing a request move the node corresponding to that request to the beginning of the linked list and make a note in some other array of length n of the element at the end of the linked list.This element is tied for furthest-in-future.Then, just scan left to right through the sequence,each time just checking some12set for which elements are currently in the cache.It can be done in constant time to check if an element is in the cache or not by a direct address table. If an element need be evicted,evict the furthest-in-future one noted earlier. This algorithm will take time O(n+m)and use additional space O(m+n). If we were in the stupid case that m>n,we could restrict our attention to the possible cache requests that actually happen,so we have a solution that is O(n)both in time and in additional space required.b.Index the subproblems c[i,S]by a number i∈[n]and a subset S∈ [m]k.Which indicates the lowest number of misses that can be achieved with an initial cache of S starting after index i.Then,c[i,S]=minx∈{S}(c[i+1,{r i}∪(S−{x})]+(1−χ{ri}(x)))which means that x is the element that is removed from the cache unless it is the current element being accessed,in which case there is no cost of eviction.c.At each time we need to add something new,we can pick which entry toevict from the cache.We need to show the there is an exchange property.That is,if we are at round i and need to evict someone,suppose we evict x.Then,if we were to instead evict the furthest in future element y,we would have no more evictions than before.To see this,since we evicted x,we will have to evict someone else once we get to x,whereas,if we had used the other strategy,we wouldn’t of had to evict anyone until we got to y.This is a point later in time than when we had to evict someone to put x back into the cache,so we could,at reloading y,just evict the person we would of evicted when we evicted someone to reload x.This causes the same number of misses unless there was an access to that element that wold of been evicted at reloading x some point in between when x any y were needed,in which case furthest in future would be better.13。

Ch10算法导论第三版第十章答案英Chapter10Michelle Bodnar,Andrew LohrApril12,2016Exercise10.1-14414134141841Exercise10.1-2We will call the stacks T and R.Initially,set T.top=0and R.top=n+1. Essentially,stack T uses the?rst part of the array and stack R uses the last part of the array.In stack T,the top is the rightmost element of T.In stack R, the top is the leftmost element of R.Algorithm1PUSH(S,x)1:if S==T then2:if T.top+1==R.top then3:error“over?ow”4:else5:T.top=T.top+16:T[T.top]=x7:end if8:end if9:if S==R then10:if R.top?1==T.top then11:error“over?ow”12:else13:R.top=R.top?1 14:T[T.top]=x 15:end if16:end if1Algorithm2POP(S) if S==T thenif T.top==0then error“under?ow”elseT.top=T.top?1. return T[T.top+1] end ifend ifif S==R thenif R.top==n+1then error“under?ow”elseR.top=R.top+1. return R[R.top?1] end ifend ifExercise10.1-34414131313838Exercise10.1-4Algorithm3ENQUEUEif Q.head==Q.tail+1,or Q.head==1and Q.tail==Q.length then error“over?ow”end ifQ[Q.tail]=xif Q.tail==Q.length thenQ.tail=1elseQ.tail=Q.head+1end ifExercise10.1-5As in the example code given in the section,we will neglect to check for over?ow and under?ow errors.2Algorithm4DEQUEUEerror“under?ow”end ifx=Q[Q.head]if Q.head==Q.length thenQ.head=1elseQ.head=Q.head+1end ifreturn xAlgorithm5HEAD-ENQUEUE(Q,x) Q[Q.head]=xif Q.head==1thenQ.head=Q.lengthelseQ.head=Q.head?1end ifAlgorithm6TAIL-ENQUEUE(Q,x) Q[Q.tail]=xif Q.tail==Q.length thenQ.tail=1elseQ.tail=Q.tail+1end ifAlgorithm7HEAD-DEQUEUE(Q,x) x=Q[Q.head]if Q.head==Q.length thenQ.head=1elseQ.head=Q.head+1end ifAlgorithm8TAIL-DEQUEUE(Q,x) x=Q[Q.tail]if Q.tail==1thenQ.tail=Q.lengthelseQ.tail=Q.tail?1end if3Exercise10.1-6The operation enqueue will be the same as pushing an element on to stack 1.This operation is O(1).To dequeue,we pop an element from stack2.If stack 2is empty,for each element in stack1we pop it o?,then push it on to stack2. Finally,pop the top item from stack2.This operation is O(n)in the worst case.Exercise10.1-7The following is a way of implementing a stack using two queues,where pop takes linear time,and push takes constant time.The?rst of these ways,consists of just enqueueing eachelement as you push it.Then,to do a pop,you dequque each element from one of the queues and place it in the other,but stopping just before the last element.Then,return the single element left in the original queue.Exercise10.2-1To insert an element in constant time,just add it to the head by making it point to the old head and have it be the head.To delete an element,it needs linear time because there is no way to get a pointer to the previous element in the list without starting at the head and scanning along.Exercise10.2-2The PUSH(L,x)operation is exactly the same as LIST-INSERT(L,x).The POP operation sets x equal to L.head,calls LIST-DELETE(L,L.head),then returns x.Exercise10.2-3In addition to the head,also keep a pointer to the last element in the linked list.To enqueue,insert the element after the last element of the list,and set it to be the new last element.T o dequeue,delete the?rst element of the list and return it.Exercise10.2-4First let L.nil.key=k.Then run LIST-SEARCH’as usual,but remove the check that x=L.nil.Exercise10.2-5To insert,just do list insert before the current head,in constant time.To search,start at the head,check if the element is the current node being in-spected,check the next element,and so on until at the end of the list or you4found the element.This can take linear time in the worst case.To delete,again linear time is used because there is no wayto get to the element immediately before the current element without starting at the head and going along the list.Exercise10.2-6Let L1be a doubly linked list containing the elements of S1and L2be a doubly linked list containing the elements of S2.We implement UNION as fol-lows:Set L1.nil.prev.next=L2.nil.next and L2.nil.next.prev=L1.nil.prev so that the last element of L1is followed by the?rst element of L2.Then set L1.nil.prev=L2.nil.prev and L2.nil.prev.next=L1.nil,so that L1.nil is the sentinel for the doubly linked list containing all the elements of L1and L2. Exercise10.2-7Algorithm9REVERSE(L)a=L.head.nextb=L.headwhile a=NIL dotmp=a.nexta.next=bb=aa=tmpend whileL.head=bExercise10.2-8We will store the pointer value for L.head separately,for convenience.In general,A XOR(A XOR C)=C,so once we know one pointer’s true value we can recover all the others(namely L.head)by applying this rule.Assuming there are at least two elements in the list,the?rst element will contain exactly the address of the second.Algorithm10LISTnp-SEARCH(L,k)p=NILx=L.headwhile x=NIL and x.key=k dotemp=xx=pXORx.npp=tempend whileTo reverse the list,we simply need to make the head be the“last”ele-5Algorithm11LISTnp-INSERT(L,x)x.np=L.headL.nil.np=xXOR(L.nil.npXORL.head)L.head=xAlgorithm12LISTnp-Delete(L,x)L.nil.np=L.nil.npXORL.headXORL.head.npL.head.np.np=L.head.np.npXORL.headment before L.nil instead of the?rst one after this.This is done by settingL.head=L.nil.npXORL.head.Exercise10.3-1A multiple array version could be L=2,/34567/124819511/23456A single array version could be L=4,127/410481371916105191311/16 Exercise10.3-2Algorithm13Allocate-Object()if free==NIL thenerror“out of space”elsex=freefree=A[x+1]end ifExercise10.3-3Allocate object just returns the index of some cells that it’s guaranteed tonot give out again until they’ve been freed.The prev attribute is not modi?ed because only the next attribute is used by the memory manager,it’s up to the code that calls allocate to use the prev and key attributes as it sees?t.Exercise10.3-4For ALLOCATE-OBJECT,we will keep track of the next available spot inthe array,and it will always be one greater than the number of elements being stored.For FREE-OBJECT(x),when a space is freed,we will decrement the6Algorithm14Free-Object(x)A[x+1]=freefree=xposition of each element in a position greater than that of x by1and update pointers accordingly.This takes linear time.Exercise10.3-5See the algorithm COMP ACT IF Y?LIST(L,F)Exercise10.4-1181274510221Note that indices8and2in the array do not appear,and,in fact do not represent a valid tree.Exercise10.4-2See the algorithm PRINT-TREE.Exercise10.4-3Exercise10.4-4See the algorithm PRINT-TREE.Exercise10.4-5See the algorithm INORDER-PRINT’(T)Exercise10.4-6Our two pointers will be left and right.For a node x,x.left will point to the leftmost child of x and x.right will point to the sibling of x immediately to its right,if it has one,and the parent of x otherwise.Our boolean value b,stored at x,will be such that b=depth(x)mod2.T o reach the parent of a node, simply keep following the“right”pointers until the parity of the boolean value changes.To?nd all the children of a node,start by?nding x.left,then follow7Algorithm15COMPACTIFY-LIST(L,F)if n=m thenreturnend ife=max{max i∈[m]{|key[i]|},max i∈L{|key[i]|}}increase every element of key[1..m]by2efor every element of L,if its key is greater than e,reduce it by2e f=1while key[f]<="" p="">f++end whilea=L.headif a>m thennext[prev[f]]=next[f]prev[next[f]]=prev[f]next[f]=next[a]key[f]=key[a]prev[f]=prev[a]F REE?OBJECT(a)f++while key[f]<="" p="">f++end whileend ifwhile a=L.head doif a>m thennext[prev[f]]=next[f]prev[next[f]]=prev[f]next[f]=next[a]key[f]=key[a]prev[f]=prev[a]F REE?OBJECT(a)f++while key[f]<="" p="">f++end whileend ifend while8Algorithm16PRINT-TREE(T.root) if T.root==NIL thenreturnelsePrint T.root.keyPRINT-TREE(T.root.left)PRINT-TREE(T.root.right)end ifAlgorithm17INORDER-PRINT(T) let S be an empty stack push(S,T)while S is not empty doU=pop(S)if U=NIL thenprint U.keypush(S,U.left)push(S,U.right)end ifend whileAlgorithm18PRINT-TREE(T.root) if T.root==NIL then returnelsePrint T.root.keyx=T.root.left?childwhile x=NIL doPRINT-TREE(x)x=x.right?siblingend whileend if9Algorithm19INORDER-PRINT’(T) a=T.leftprev=Twhile a=T doif prev=a.left thenprint a.keyprev=aa=a.rightelse if prev=a.right thenprev=aa=a.pelse if prev=a.p thenprev=aa=a.leftend ifend whileprint T.keya=T.rightwhile a=T doif prev=a.left thenprint a.keyprev=aa=a.rightelse if prev=a.right thenprev=aa=a.pelse if prev=a.p thenprev=aa=a.leftend ifend while10the“right”pointers until the parity of the boolean value changes,ignoring thislast node since it will be x.Problem10-1For each,we assume sorted means sorted in ascending order unsorted,single sorted,single unsorted,double sorted,double SEARCH(L,k)n n n nINSERT(L,x)1111DELET E(L,x)n n11SUCCESSOR(L,x)n1n1P REDECESSOR(L,x)n n n1 MINIMUM(L,x)n1n1MAXIMUM(L,x)n n n1 Problem10-2In all three cases,MAKE-HEAP simply creates a new list L,sets L.head=NIL,and returns L in constant time.Assume lists are doubly linked.T o realizea linked list as a heap,we imagine the usual array implementation of a binaryheap,where the children of the i th element are2i and2i+1.a.To insert,we perform a linear scan to see where to insert an element suchthat the list remains sorted.This takes linear time.The?rst element in thelist is the minimum element,and we can?nd it in constant time.Extract-minreturns the?rst element of the list,then deletes it.Union performs a mergeoperation between the two sorted lists,interleaving their entries such thatthe resulting list is sorted.This takes time linear in the sum of the lengthsof the two lists.b.To insert an element x into the heap,begin linearly scanning the list untilthe?rst instance of an element y which is strictly larger than x.If no suchlarger element exists,simply insert x at the end of the list.If y does exist,replace y t by x.This maintains the min-heap property because x≤y andy was smaller than each of its children,so x must be as well.Moreover,xis larger than its parent because y was the?rst element in the list to exceedx.Now insert y,starting the scan at the node following x.Since we checkeach node at most once,the time is linear in the size of the list.To get theminimum element,return the key of the head of the list in constant time.To extract the minimum element,we?rst call MINIM UM.Next,we’ll replacethe key of the head of the list by the key of the second smallest element yin the list.We’ll take the key stored at the end of the list and use it toreplace the key of y.Finally,we’ll delete the last element of the list,and callMIN-HEAPIFY on the list.T o implement this with linked lists,we need tostep through the list to get from element i to element2i.We omit this detailfrom the code,but we’ll consider it for runtime analysis.Since the value ofi on which MIN-HEAPIFY is called is always increasing and we never need11to step through elements multiple times,the runtime is linear in the length of the list.Algorithm20EXTRACT-MIN(L)min=MINIMUM(L)Linearly scan for the second smallest element,located in position i.L.head.key=L[i]L[i].key=L[L.length].keyDELETE(L,L[L.length])MIN-HEAPIFY(L[i],i)return minAlgorithm21MIN-HEAPIFY(L[i],i)1:l=L[2i].key2:r=L[2i+1].key3:p=L[i].key4:smallest=i5:if L[2i]=NIL and l6:smallest=2i7:end if8:if L[2i+1]=NIL and r<l[smallest]then< bdsfid="416" p=""></l[smallest]then<>9:smallest=2i+110:end if11:if smallest=i then12:exchange L[i]with L[smallest]13:MIN-HEAPIFY(L[smallest],smallest)14:end ifUnion is implemented below,where we assume A and B are the two list representations of heaps to be merged.The runtime is again linear in the lengths of the lists to be merged.c.Since the algorithms in part b didn’t depend on the elements being distinct,we can use the same ones.Problem10-3a.If the original version of the algorithm takes only t iterations,then,we havethat it was only at most t random skips though the list to get to the desired value,since each iteration of the original while loop is a possible random jump followed by a normal step through the linked list.b.The for loop on lines2-7will get run exactly t times,each of which is constantruntime.After that,the while loop on lines8-9will be run exactly X t times.So,the total runtime is O(t+E[X t]).12Algorithm22UNION(A,B)1:if A.head=NIL then2:return B3:end if4:i=15:x=A.head6:while B.head=NIL do7:if B.head.key≤x.key then8:Insert a node at the end of list B with key x.key9:x.key=B.head.key10:Delete(B,B.head)11:end if x=x.next12:end while13:return A/doc/8010751696.html,ing equation C.25,we have that E[X t]= ∞i=1P r(X t≥i).So,we needto show that P r(X t≥i)≤(1?i/n)t.This can be seen because having X t being greater than i means that each random choice will result in an element that is either at least i steps before the desired element,or is after the desired element.There are n?i such elements,out of the total n elements that we were pricking from.So,for a single one of the choices to be from such a range, we have a probability of(n?i)/n=(1?i/n).Since each of the selections was independent,the total probability that all of them were is(1?i/n)t, as /doc/8010751696.html,stly,we can note that since the linked list has length n,the probability that X t is greater than n is equal to zero.d.Since we have that t>0,we know that the function f(x)=x t is increasing,so,that means that x t≤f(x).So,n?1r=0r t=nr t dr≤nf(r)dr=e.E[X t]≤nr=1 (1?r/n)t= nr=1ti=0ti(?r/n)i= ti=0nr=1ti(?r/n)i =ti=0ti(?1)in i?1+ n?1r=0 (r)tti=0ti(?1)in i?1+n i+1/n ≤ti=0ti(?1)in ii+1=1t+1ti=0t+1i+1(?n)i≤(1?n)t+1t+1f.We just put together parts b and e to get that it runs in time O(t+n/(t+1)).But,this is the same as O(t+n/t).13g.Since we have that for any number of iterations t that the ?rst algorithm takes to ?nd its answer,the second algorithm will return it in time O (t +n/t ).In particular,if we just have that t =√n .The second algorithm takestime only O (√n ).This means that tihe ?rst list search algorithm is O (√n )as well.h.If we don’t have distinct key values,then,we may randomly select an element that is further along than we had been before,but not jump to it because it has the same key as what we were currently at.The analysis will break when we try to bound the probability that X t ≥i .14。

Chapter23Michelle Bodnar,Andrew LohrApril12,2016Exercise23.1-1Suppose that A is an empty set of edges.Then,make any cut that has(u,v) crossing it.Then,since that edge is of minimal weight,we have that(u,v)is a light edge of that cut,and so it is safe to add.Since we add it,then,once wefinish constructing the tree,we have that(u,v)is contained in a minimum spanning tree.Exercise23.1-2Let G be the graph with4vertices:u,v,w,z.Let the edges of the graph be (u,v),(u,w),(w,z)with weights3,1,and2respectively.Suppose A is the set {(u,w)}.Let S=A.Then S clearly respects A.Since G is a tree,its minimum spanning tree is itself,so A is trivially a subset of a minimum spanning tree. Moreover,every edge is safe.In particular,(u,v)is safe but not a light edge for the cut.Therefore Professor Sabatier’s conjecture is false.Exercise23.1-3Let T0and T1be the two trees that are obtained by removing edge(u,v) from a MST.Suppose that V0and V1are the vertices of T0and T1respectively. Consider the cut which separates V0from V1.Suppose to a contradiction that there is some edge that has weight less than that of(u,v)in this cut.Then,we could construct a minimum spanning tree of the whole graph by adding that edge to T1∪T0.This would result in a minimum spanning tree that has weight less than the original minimum spanning tree that contained(u,v).Exercise23.1-4Let G be a graph on3vertices,each connected to the other2by an edge, and such that each edge has weight1.Since every edge has the same weight, every edge is a light edge for a cut which it spans.However,if we take all edges we get a cycle.1Exercise23.1-5Let A be any cut that causes some vertices in the cycle on once side of the cut,and some vertices in the cycle on the other.For any of these cuts,we know that the edge e is not a light edge for this cut.Since all the other cuts wont have the edge e crossing it,we won’t have that the edge is light for any of those cuts either.This means that we have that e is not safe.Exercise23.1-6Suppose that for every cut of the graph there is a unique light edge crossing the cut,but that the graph has2spanning trees T and T .Since T and T are distinct,there must exist edges(u,v)and(x,y)such that(u,v)is in T but not T and(x,y)is in T but not T.Let S={u,x}.There is a unique light edge which spans this cut.Without loss of generality,suppose that it is not(u,v). Then we can replace(u,v)by this edge in T to obtain a spanning tree of strictly smaller weight,a contradiction.Thus the spanning tree is unique.For a counter example to the converse,let G=(V,E)where V={x,y,z} and E={(x,y),(y,z),(x,z)}with weights1,2,and1respectively.The unique minimum spanning tree consists of the two edges of weight1,however the cut where S={x}doesn’t have a unique light edge which crosses it,since both of them have weight1.Exercise23.1-7First,we show that the subset of edges of minimum total weight that con-nects all the vertices is a tree.To see this,suppose not,that it had a cycle. This would mean that removing any of the edges in this cycle would mean that the remaining edges would still connect all the vertices,but would have a total weight that’s less by the weight of the edge that was removed.This would con-tradict the minimality of the total weight of the subset of vertices.Since the subset of edges forms a tree,and has minimal total weight,it must also be a minimum spanning tree.To see that this conclusion is not true if we allow negative edge weights,we provide a construction.Consider the graph K3with all edge weights equal to −1.The only minimum weight set of edges that connects the graph has total weight−3,and consists of all the edges.This is clearly not a MST because it is not a tree,which can be easily seen because it has one more edge than a tree on three vertices should have.Any MST of this weighted graph must have weight that is at least-2.Exercise23.1-8Suppose that L is another sorted list of edge weights of a minimum span-ning tree.If L =L,there must be afirst edge(u,v)in T or T which is of smaller weight than the corresponding edge(x,y)in the other set.Without2loss of generality,assume(u,v)is in T.Let C be the graph obtained by adding (u,v)to L .Then we must have introduced a cycle.If there exists an edge on that cycle which is of larger weight than(u,v),we can remove it to obtain a tree C of weight strictly smaller than the weight of T ,contradicting the fact that T is a minimum spanning tree.Thus,every edge on the cycle must be of lesser or equal weight than(u,v).Suppose that every edge is of strictly smaller weight.Remove(u,v)from T to disconnect it into two components.There must exist some edge besides(u,v)on the cycle which would connect these,and since it has smaller weight we can use that edge instead to create a spanning tree with less weight than T,a contradiction.Thus,some edge on the cycle has the same weight as(u,v).Replace that edge by(u,v).The corresponding lists L and L remain unchanged since we have swapped out an edge of equal weight, but the number of edges which T and T have in common has increased by1. If we continue in this way,eventually they must have every edge in common, contradicting the fact that their edge weights differ somewhere.Therefore all minimum spanning trees have the same sorted list of edge weights.Exercise23.1-9Suppose that there was some cheaper spanning tree than T .That is,we have that there is some T so that w(T )<w(T ).Then,let S be the edges in T but not in T .We can then construct a minimum spanning tree of G by considering S∪T .This is a spanning tree since S∪T is,and T makes all the vertices in V connected just like T does.However,we have that w(S∪T )=w(S)+w(T )<w(S)+w(T )=w(S∪T )=w(T).This means that we just found a spanning tree that has a lower total weight than a minimum spanning tree.This is a contradiction,and so our assumption that there was a spanning tree of V cheaper than T must be false.Exercise23.1-10Suppose that T is no longer a minimum spanning tree for G with edge weights given by w .Let T be a minimum spanning tree for this graph.Then we have we have w (T )<w(T)−k.Since the edge(x,y)may or may not be in T we have w(T )≤w (T )+k<w(T),contradicting the fact that T was minimal under the weight function w.Exercise23.1-11If we were to add in this newly decreased edge to the given tree,we would be creating a cycle.Then,if we were to remove any one of the edges along this cycle,we would still have a spanning tree.This means that we look at all the weights along this cycle formed by adding in the decreased edge,and remove the edge in the cycle of maximum weight.This does exactly what we want since we could only possibly want to add in the single decreased edge,and then,from there we change the graph back to a tree in the way that makes its total weight3minimized.Exercise23.2-1Suppose that we wanted to pick T as our minimum spanning tree.Then,to obtain this tree with Kruskal’s algorithm,we will order the edgesfirst by their weight,but then will resolve ties in edge weights by picking an edgefirst if it is contained in the minimum spanning tree,and treating all the edges that aren’t in T as being slightly larger,even though they have the same actual weight. With this ordering,we will still befinding a tree of the same weight as all the minimum spanning trees w(T).However,since we prioritize the edges in T,we have that we will pick them over any other edges that may be in other minimum spanning trees.Exercise23.2-2At each step of the algorithm we will add an edge from a vertex in the tree created so far to a vertex not in the tree,such that this edge has minimum weight.Thus,it will be useful to know,for each vertex not in the tree,the edge from that vertex to some vertex in the tree of minimal weight.We will store this information in an array A,where A[u]=(v,w)if w is the weight of(u,v) and is minimal among the weights of edges from u to some vertex v in the tree built so far.We’ll use A[u].1to access v and A[u].2to access w.Algorithm1PRIM-ADJ(G,w,r)Initialize A so that every entry is(NIL,∞)T={r}for i=1to V doif Adj[r,i]=0thenA[i]=(r,w(r,i))end ifend forfor each u∈V−T dok=min i A[i].2T=T∪{k}k.π=A[k].1for i=1to V doif Adj[k,i]=0and Adj[k,i]<A[i].2thenA[i]=(k,Adj[k,i])end ifend forend forExercise23.2-34Prim’s algorithm implemented with a Binary heap has runtime O((V+ E)lg(V)),which in the sparse case,is just O(V lg(V)).The implementation with Fibonacci heaps is O(E+V lg(V))=O(V+V lg(V))=O(V lg(V)).So, in the sparse case,the two algorithms have the same asymptotic runtimes.In the dense case,we have that the binary heap implementation has runtime O((V+E)lg(V))=O((V+V2)lg(V))=O(V2lg(V)).The Fibonacci heap implementation however has a runtime of O(E+V lg(V))=O(V2+V lg(V))= O(V2).So,in the dense case,we have that the Fibonacci heap implementation is asymptotically faster.The Fibonacci heap implementation will be asymptotically faster so long as E=ω(V).Suppose that we have some function that grows more quickly than linear,say f,and E=f(V).The binary heap implementation will have runtime O((V+E)lg(V))=O((V+f(V))lg(V))=O(f(V)lg(V)).However, we have that the runtime of the Fibonacci heap implementation will have run-time O(E+V lg(V))=O(f(V)+V lg(V)).This runtime is either O(f(V))or O(V lg(V))depending on if f(V)grows more or less quickly than V lg(V)re-spectively.In either case,we have that the runtime is faster than O(f(V)lg(V)).Exercise23.2-4If the edge weights are integers in the range from1to|V|,we can make Kruskal’s algorithm run in O(Eα(V))time by using counting sort to sort the edges by weight in linear time.I would take the same approach if the edge weights were integers bounded by a constant,since the runtime is dominated by the task of deciding whether an edge joins disjoint forests,which is independent of edge weights.Exercise23.2-5If there the edge weights are all in the range1,...,|V|,then,we can imagine adding the edges to an array of lists,where the edges of weight i go into the list in index i in the array.Then,to decrease an element,we just remove it from the list currently containing it(constant time)and add it to the list corresponding to its new value(also constant time).To extract the minimum wight edge,we maintain a linked list among all the indices that contain non-empty lists,which can also be maintained with only a constant amount of extra work.Since all of these operations can be done in constant time,we have a total runtime O(E+V).If the edge weights all lie in some bounded universe,suppose in the range 1to W.Then,we can just vEB tree structure given in chapter20to have the two required operations performed in time O(lg(lg(W))),which means that the total runtime could be made O((V+E)lg(lg(W))).Exercise23.2-6For input drawn from a uniform distribution I would use bucket sort with5Kruskal’s algorithm,for expected linear time sorting of edges by weight.This would achieve expected runtime O(Eα(V)).Exercise23.2-7Wefirst add all the edges to the new vertex.Then,we preform a DFS rooted at that vertex.As we go down,we keep track of the largest weight edge seen so far since each vertex above us in the DFS.We know from exercise23.3-6that in a directed graph,we don’t need to consider cross or forward edges.Every cycle that we detect will then be formed by a back edge.So,we just remove the edge of greatest weight seen since we were at the vertex that the back edge is going to.Then,we’ll keep going until we’ve removed one less than the degree of the vertex we added many edges.This will end up being linear time since we can reuse part of the DFS that we had already computed before detecting each cycle.Exercise23.2-8Professor Borden is mistaken.Consider the graph with4vertices:a,b,c, and d.Let the edges be(a,b),(b,c),(c,d),(d,a)with weights1,5,1,and5 respectively.Let V1={a,d}and V2={b,c}.Then there is only one edge incident on each of these,so the trees we must take on V1and V2consist of precisely the edges(a,d)and(b,c),for a total weight of10.With the addition of the weight1edge that connects them,we get weight11.However,an MST would use the two weight1edges and only one of the weight5edges,for a total weight of7.Problem23-1a.To see that the second best minimum spanning tree need not be unique,weconsider the following example graph on four vertices.Suppose the vertices are{a,b,c,d},and the edge weights are as follows:a b c da−143b1−52c45−6d326−Then,the minimum spanning tree has weight7,but there are two spanning trees of the second best weight,8.b.We are trying to show that there is a single edge swap that can demote ourminimum spanning tree to a second best minimum spanning tree.In obtaining the second best minimum spanning tree,there must be some cut of a single vertex away from the rest for which the edge that is added is not light,otherwise,we wouldfind the minimum spanning tree,not the second best minimum spanning tree.Call the edge that is selected for that cut for6the second best minimum spanning tree(x,y).Now,consider the same cut, except look at the edge that was selected when obtaining T,call it(u,v).Then,we have that if consider T−{(u,v)}∪{(x,y)},it will be a second best minimum spanning tree.This is because if the second best minimum spanning tree also selected a non-light edge for another cut,it would end up more expensive than all the minimum spanning trees.This means that we need for every cut other than the one that the selected edge was light.This means that the choices all align with what the minimum spanning tree was.c.We give here a dynamic programming solution.Suppose that we want tofind it for(u,v).First,we will identify the vertex x that occurs immediately after u on the simple path from u to v.We will then make max[u,v]equal to the max of w((u,x))and max[w,v].Lastly,we just consider the case that u and v are adjacent,in which case the maximum weight edge is just the single edge between the two.If we canfind x in constant time,then we will have the whole dynamic program running in time O(V2),since that’s the size of the table that’s being built up.Tofind x in constant time,we preprocess the tree.Wefirst pick an arbitrary root.Then,we do the preprocessing for Tarjan’s off-line least common an-cestors algorithm(See problem21-3).This takes time just a little more than linear,O(|V|α(|V|)).Once we’ve computed all the least common ancestors, we can just look up that result at some point later in constant time.Then, tofind the w that we should pick,wefirst see if u=LCA(u,v)if it does not,then we just pick the parent of u in the tree.If it does,then weflip the question on its head and try to compute max[v,u],we are guaranteed to not have this situation of v=LCA(v,u)because we know that u is an ancestor of v.d.We provide here an algorithm that takes time O(V2)and leave open if thereexists a linear time solution,that is a O(E+V)time solution.First,we find a minimum spanning tree in time O(E+V lg(V)),which is in O(V2).Then,using the algorithm from part c,wefind the double array max.Then, we take a running minimum over all pairs of vertices u,v,of the value of w(u,v)−max[u,v].If there is no edge between u and v,we think of the weight being infinite.Then,for the pair that resulted in the minimum value of this difference,we add in that edge and remove from the minimum spanning tree, an edge that is in the path from u to v that has weight max[u,v].Problem23-2a.We’ll show that the edges added at each step are safe.Consider an un-marked vertex u.Set S={u}and let A be the set of edges in the tree so far. Then the cut respects A,and the next edge we add is a light edge,so it is safe for A.Thus,every edge in T before we run Prim’s algorithm is safe for T.Any edge that Prim’s would normally add at this point would have to connect two7of the trees already created,and it would be chosen as minimal.Moreover,we choose exactly one between any two trees.Thus,the fact that we only have the smallest edges available to us is not a problem.The resulting tree must be minimal.b.We argue by induction on the number of vertices in G.We’ll assume that|V|>1,since otherwise MST-REDUCE will encounter an error on line6 because there is no way to choose v.Let|V|=2.Since G is connected,there must be an edge between u and v,and it is trivially of minimum weight.They are joined,and|G .V|=1=|V|/2.Suppose the claim holds for|V|=n.Let G be a connected graph on n+1vertices.Then G .V≤n/2prior to thefinal vertex v being examined in the for-loop of line4.If v is marked then we’re done, and if v isn’t marked then we’ll connect it to some other vertex,which must be marked since v is the last to be processed.Either way,v can’t contribute an additional vertex to G .V,so|G .V|≤n/2≤(n+1)/2.c.Rather than using the disjoint set structures of chapter21,we can simply use an array to keep track of which component a vertex is in.Let A be an array of length|V|such that A[u]=v if v=F IND−SET(u).Then FIND-SET(u) can now be replaced with A[u]and UNION(u,v)can be replaced by A[v]=A[u]. Since these operations run in constant time,the runtime is O(E).d.The number of edges in the output is monotonically decreasing,so each call is O(E).Thus,k calls take O(kE)time.e.The runtime of Prim’s algorithm is O(E+V lg V).Each time we run MST-REDUCE,we cut the number of vertices at least in half.Thus,af-ter k calls,the number of vertices is at most|V|/2k.We need to minimizeE+V/2k lg(V/2k)+kE=E+V lg(V)k −V kk+kE with respect to k.If we choosek=lg lg V then we achieve the overall running time of O(E lg lg V)as desired.To see that this value of k minimizes,note that the V k2k term is always less thanthe kE term since E≥V.As k decreases,the contribution of kE decreases,and the contribution of V lg V2k increases.Thus,we need tofind the value of kwhich makes them approximately equal in the worst case,when E=V.Todo this,we set lg V2k =k.Solving this exactly would involve the Lambert Wfunction,but the nicest elementary function which gets close is k=lg lg V.f.We simply set up the inequality E lg lg V<E+V lg V tofind that weneed E<V lg Vlg lg V−1=OV lg Vlg lg V.Problem23-3a.To see that every minimum spanning tree is also a bottleneck spanning tree.Suppose that T is a minimum spanning tree.Suppose there is some edge in it(u,v)that has a weight that’s greater than the weight of the bottleneck8spanning tree.Then,let V1be the subset of vertices of V that are reach-able from u in T,without going though v.Define V2symmetrically.Then, consider the cut that separates V1from V2.The only edge that we could add across this cut is the one of minimum weight,so we know that there are no edge across this cut of weight less than w(u,v).However,we have that there is a bottleneck spanning tree with less than that weight.This is a contradiction because a bottleneck spanning tree,since it is a spanning tree, must have an edge across this cut.b.To do this,wefirst process the entire graph,and remove any edges thathave weight greater than b.If the remaining graph is selected,we can just arbitrarily select any tree in it,and it will be a bottleneck spanning tree of weight at most b.Testing connectivity of a graph can be done in linear time by running a breadthfirst search and then making sure that no vertices remain white at the end.c.Write down all of the edge weights of e the algorithm from section9.3tofind the median of this list of numbers in time O(E).Then,run theprocedure from part b with this median value as the one that you are testing for there to be a bottleneck spanning tree with weight at most.Then there are two cases:First,we could have that there is a bottleneck spanning tree with weight at most this median.Then just throw the edges with weight more than the median,and repeat the procedure on this new graph with half the edges.Second,we could have that there is no bottleneck spanning tree with at most that weight.Then,we should run the procedure from problem23-2 to contract all of the edges that have weight at most this median weight.This takes time O(E lg(lg(V)))and then we are left solving the problem ona graph that now has half the vertices.Problem23-4a.This does return an MST.To see this,we’ll show that we never remove anedge which must be part of a minimum spanning tree.If we remove e,thene cannot be a bridge,which means that e lies on a simple cycle of the graph.Since we remove edges in nonincreasing order,the weight of every edge on the cycle must be less than or equal to that of e.By exercise23.1-5,there isa minimum spanning tree on G with edge e removed.To implement this,we begin by sorting the edges in O(E lg E)time.For each edge we need to check whether or not T−{e}is connected,so we’ll need to run a DFS.Each one takes O(V+E),so doing this for all edges takes O(E(V+E).This dominates the running time,so the total time is O(E2).9b.This doesn’t return an MST.To see this,let G be the graph on3verticesa,b,and c.Let the eges be(a,b),(b,c),and(c,a)with weights3,2,and1 respectively.If the algorithm examines the edges in their order listed,it will take the two heaviest edges instead of the two lightest.An efficient implementation will use disjoint sets to keep track of connected components,as in MST-REDUCE in problem23-2.Trying to union within the same component will create a cycle.Since we make|V|calls to MAKE-SET and at most3|E|calls to FIND-SET and UNION,the runtime is O(Eα(V)).c.This does return an MST.To see this,we simply quote the result from exer-cise23.1-5.The only edges we remove are the edges of maximum weight on some cycle,and there always exists a minimum spanning tree which doesn’t include these edges.Moreover,if we remove an edge from every cycle then the resulting graph cannot have any cycles,so it must be a tree.To implement this,we use the approach taken in part(b),except now we also need tofind the maximum weight edge on a cycle.For each edge which introduces a cycle we can perform a DFS tofind the cycle and max weight edge.Since the tree at that time has at most one cycle,it has at most|V| edges,so we can run DFS in O(V).The runtime is thus O(EV).10。