CRACKING CODING INTERVIEW

Transcription

1 CRACKING tlie CODING INTERVIEW 6th Editio 189 Programmig Questios ad Solutios GAYLE LAAKMANN MCDOWELL Fouder ad CEO, CareerCup.com CareerCup, LLC Palo Alto, CA

2 CRACKING THE CODING INTERVIEW,SIXTH EDITION Copyright 2016 by CareerCup. All rights reserved. No part of this book may be reproduced i ay form by ay electroic or mechaical meas, icludig iformatio storage ad retrieval systems, without permissio i writig from the author or publisher,except by a reviewer who may quote brief passages i a review. Published by CareerCup, LLC, Palo Alto, CA. Compiled Ju 14, For more iformatio, cotact support@careercup.com (ISBN 13)

3 XI Advaced Topics Whe writig the 6th editio, I had a umber of debates about what should ad should't be icluded. Red-black trees? Dijkstra's algorith m?topological sort? O oe had, I'd had a umber of requests to iclude these topics. Some people isisted that these topics are asked "all the time"(i which case, they have a very differet idea of what this phrase meas!). There was clearly a desire-at least from some people-to iclude them. Ad learig more ca't hurt, right? O the other had, I kow these topics to be rarely asked. It happes, of course. Iterviewers are idividuals ad might have their ow ideas of what is"fa ir game"or"relevat"for a iterview. But it's rare. Whe it does come up, if you do't kow the topic, it's ulikely to be a big red flag. I Admittedly, as a iterviewer, I have asked cadidates questios where the solutio was essetially a applicatio of oe of these algorithms. O the rare occasios that a cadidate already kew the algorithm, they did ot beefit from this kowledge (or were they hurt by it). I wat to evaluate your ability to solve a problem you have't see before. So, I'll take ito accout whether you kow the uderlyig algorithm i advace. I believe i givig people a fair expectatio of the iterview, ot scarig people ito excess studyig. I also have o iterest i makig the book more "advaced" so as to help book sales, at the expese of your time ad eergy. That's ot fair or right to do to you. (Additioally, I did't wat to give iterviewers-who I kow to be readig this-the impressio that they ca or should be coverig these more advaced topics. Iterviewers: If you ask about these topics, you're testig kowledge of algorithms. You're just goig to wid up elimiatig a lot of perfectly smart people.) But there are may borderlie "importat" topics. They're ot ofte asked, but sometimes they are. Ultimately, I decided to leave the decisio i your hads. After all, you kow better tha I do how thorough you wat to be i your preparatio. If you wat to do a extra thorough job, read this. If you just love learig data structures ad algorithms, read this. If you wat to see ew ways of approachig problems, read this. But if you're pressed for time, this studyig is't a super high priority. Useful Math Here's some math that ca be useful i some questios. There are more formal proofs that you ca look up olie, but we'll focus here o givig you the ituitio behid them. You ca thik of these as iformal proofs. CrackigTheCodiglterv i ew.com I 6th Editio 629

4 XI. Advaced Topics Sum of Itegers 1 through N What is ? Let's figure it out by pairig up low values with high values. If is eve, we pair 1 with, 2 with - 1, ad so o. We will have T pairs each with sum + 1. If is odd, we pair O with, 1 with - 1, ad so o. We will have +!. pairs with sum. is eve is odd pair# a b a+b pair# a b a+b T total: T f+l f *(+l) (+l) I either case, the sum is l total: l !:!.:p- *... This reasoig comes up a lot i ested loops. For example, cosider the followig code: 1 for (iti= 0; i < ; i++) { 2 for (it j = i + 1; j < ; j++) { 3 System.out.pr itl(i+ j); 4 } 5 } O the first iteratio of the outer for loop, the ier for loop iterates - 1 times. O the secod iteratio of the outer for loop, the ier for loop iterates -2 ti mes. Next, - 3, the - 4, ad so o. There are (-ll 2 total iteratios of the ier for loop. Therefore, this code takes 0( 2 ) time. Sum of Powers of 2 Cosider this sequece: ". What is its result? A ice way to see this is by lookig at these values i biary. Power Biary sum: Decimal = 31 Therefore, the sum of " would, i base 2, be a sequece of ( + 1) 1 s. This is 2" Takeaway:The sum of a sequece of powers of two is roughly equal to the ext value i the sequece. Bases of Logs Suppose we have somethig i log 2 (log base 2). How do we covert that to log 10? That is, what's the relatioship betwee log b k ad log,k? 630 Crackig the Codig Iterview, 6th Editio

5 XI. Advaced Topics Let's do some math. Assume c = logbk ad y = log_k. log.k = c --> b' = k // This is the defiitio of log. log,(b') = log,k // Take log of both sides of b' = k. c log,b = log,k // Rules of logs. You ca move out the expoets. C = logbk = l og, xo g, b // Dividig above expressio ad substitutig C. Therefore, if we wat to covert log 2 ptolog 10, wejustd othis: log1p logiop = log210 Takeaway: Logs of differet bases are oly off by a costat factor. For this reaso, we largely igore what the base of a log withi a big O expressio. It does't matter sice we drop costats ayway. Permutatios How may ways are there of rearragig a strig of uique characters?well, you have optios for what to put i the first characters, the - 1 optios for what to put i the secod slot (oe optio is take), the - 2 optios for what to put i the third slot, ad so o. Therefore, the total umber of strigs is!.! = *!l...:.. *!l...:. *!!...: *... * 1 What if you were formig a k-legth strig (with a uique characters) from total uique characters?you ca follow similar logic, but you'd just stop your selectio/multiplicatio earlier. Combiatios! (-k)! Q *!1...:.. *!l...:. *!!...: *... * - k + l Suppose you have a set of distict characters. How may ways are there of selectig k characters ito a ew set (where order does't matter)? That is, how may k-sized subsets a here out of distict elemets? This is what the expressio -choose-k meas, which is ofte writte l k ). Imagie we made a list of all the sets by first writig all k-legth substrigs ad the takig out the dupli cates. From the above Permutatios sectio, we'd have "Yc. kl I k-legth substrigs. Sice each k-sized subset ca be rearraged k! uique ways ito a strig, each subset will be duplicated k! times i this list of substrigs. Therefore, we eed to divide by k! to take out these duplicates. Proof by Iductio ( ) 1 *!! k =rr (-k)! = k!(-k)! Iductio is a way of provig somethig to be true. It is closely related to recursio. It takes the followig form. Task:Prove statemetp{k) istrueforallk >= b. Base Case: Prove the statemet is true for P ( b). This is usually just a matter of pluggig i umbers. Assumptio: Assume the statemet is true for P{ ). Iductive Step: Prove that if the statemet is true for P { ), the it's true for P{ +l). This is like domioes. If the first domio falls, ad oe domio always kocks over the ext oe, the a the domioes must fa. Let's use this to prove that there are 2" subsets of a -elemet set. Defiitios: let S = { a" a 2, a 3,, a.} be the -elemet set. CrackigTheCodiglterv i ew.com I 6th Editio 631

6 XI. Advaced Topics Base case: Prove there are 2 subsets of{}. This is true, sice the oly subset of{} is { }. Assume that there are 2" subsets of { a., a 1, a l, Prove that there are 2" 1 subsets of { a l ' a 2, a ), Cosider the subsets of { a 1, a 1, a l,..., a 1 }. Exactly half will cotai a ad half will ot. The subsets that do ot cotai a 1 are just the subsets of {a., a 1, a l '..., a.}. We assumed there are 2" of those. Sice we have the same umber of subsets with x as without x, there are 2 subsets with a 1. Therefore, we have 2" + 2" subsets, which is 2 1 May recursive algorithms ca be proved valid with iductio....,....,., Topological Sort A topological sort of a directed graph is a way of orderig the list of odes such that if {a, b) is a edge i the graph the a will appear before bi the list. If a graph has cycles or is ot directed, the there is o topological sort. There are a umber of applicatios for th is. For example, suppose the graph represets parts o a assembly lie. The edge (Hadle, Door) idicates that you eed to assemble the hadle before the door. The topological sort would offer a valid orderig for the assembly lie. We ca costruct a topological sort with the followig approach. 1. Idetify all odes with o icomig edges ad add those odes to our topological sort.» We kow those odes are safe to add first sice they have othig that eeds to come before them. Might as we get them over with!» We kow that such a ode must exist if there's o cycle. After all, if we picked a arbitrary ode we could just walk edges backwards arbitrarily. We'll either stop at some poit (i which case we've foud a ode with o icomig edges) or we'll retur to a prior ode (i which case there is a cycle). 2. Whe we do the above, remove each ode's outboud edges from the graph.» Those odes have already bee added to the topological sort, so they're basically irrelevat. We ca't violate those edges aymore. 3. Repeat the above, addig odes with o icomig edges ad removig their outboud edges. Whe all the odes have bee added to the topological sort, the we are doe. More formally, the algorithm is this: 1. Create a queue order, which will evetually store the valid topological sort. It is curretly empty. 2. Create a queue processnext. This queue will store the ext odes to process. 3. Cout the umber of icomig edges of each ode ad set a class variable ode. iboud. Nodes typically oly store their outgoig edges. However, you ca cout the iboud edges by walkig through each ode ad, for each of its outgoig edges {, x), icremetig x. iboud. 4. Walk through theodesagai ad add to processnext ayodewhere x. iboud WhileprocessNext isot empty,dothe followig:» Remove first ode from proce s snext. 632 Crackig the Codig Iterview, 6th Editio

7 XI. Advaced Topics» For each edge (, x), decremet x. i boud.lfx. iboud == 0,apped xto processnext.» Apped to order. 6. If order cotais all the odes, the it has succeeded. Otherwise, the topological sort has failed due to a cycle. This algorithm does sometimes come up i iterview questios. Your iterviewer probably would't expect you to kow it offhad. However, it would be reasoable to have you derive it eve if you've ever see it before. Dijkstra's Algorithm I some graphs, we might wat to have edges with weights. If the graph represeted cities, each edge might represet a road ad its weight might represet the travel time. I this case, we might wat to ask, just as your GPS mappig system does, what's the shortest path from your curret locatio to aother poit p?this is where Dijksta's algorithm comes i. Dijkstra's algorithm is a way to fid the shortest path betwee two poits i a weighted directed graph (which might have cycles). All edges must have positive values. Rather tha just statig what Dijkstra's algorithm is, let's try to derive it. Cosider the earlier described graph. We could fid the shortest path from s to t by literally takig all possible routes usig actual time. (Oh, ad we'll eed a machie to cloe ourselves.) 1. Start off at s. 2. For each of s's outboud edges, cloe ourselves ad start walkig. If the edge ( s, x) has weight 5, we should actually take 5 miutes to get there. 3. Each time we get to a ode, check if ayoe's bee there before. If so, the just stop. We're automatically ot as fast as aother path sice someoe beat us here from s. If o oe has bee here before, the cloe ourselves ad head out i all possible directios. 4. The first oe to get to t wis. This works just fie. But, of course, i the real algorithm we do't wat to literally use a timer to fid the shortest path. Imagie that each cloe could jump immediately from oe ode to its adjacet odes (regardless of the edge weight), but it kept a time_so_ far log of how log its path would have take if it did walk at the "true" speed. Additioally, oly oe perso moves at a time, ad it's always the oe with the lowest time_ so_ far. This is sort of how Dijkstra's algorithm works. Dijkstra's algorithm fids the miimum weight path from a start ode s to every ode o the graph. Cosider the followig graph. CrackigTheCodiglterview.com I 6th Editio 633

8 XI. Advaced Topics Assume we are tryig to fid the shortest path from a to i. We'll use Dijkstra's algorithm to fid the shortest path from a to all other odes, from which we will clearly have the shortest path from a to i. We first iitialize several variables: path_weight [ode]: maps from each ode to the total weight of the shortest path. All values are iitialized to ifiity, except for pat h_weight [a] which is iitialized to 0. pre vious [ode]: maps from each ode to the previous ode i the (curret) shortest path. remaiig: a priority queue of all odes i the graph, where each ode's priority is defied by its path_weight. Oce we've iitialized these values, we ca start adjustig the values of pat h_weight. I A (mi) priority queue is a abstract data type that-at least i this case-supports isertio of a object ad key, removig the object with the miimum key, ad decreasig a key. (Thik of it like a typical queue, except that, istead of removig the oldest item, it removes the item with the lowest or highest priority.) It is a abstract data type because it is defied by its behavior (its operatios). Its uderlyig implemetatio ca vary. You could implemet a priority queue with a array or a mi (or max) heap (or may other data structures). We iterate through the odes i remaiig (util remaiig is empty), doig the followig: 1. Select the ode i remaiig with the lowest value i path_weight. Call this ode. 2. For each adjacet ode, compare pat h_weight[ x] (which is the weight of the curret shortest path from a to x) to path_weight [] + edge_weight [ (, x) ].That is, could we get a path from a to x with lower weight by goig through istead of our curret path? If so, update pat h_weight ad previous. 3. Remove from remaiig. Whe remaiig is empty, the pat h_weight stores the weight of the curret shortest path from a to each ode. We ca recostruct this path by tracig through previous. Let's walk through this o the above graph. 1. The first value of is a. We look at its adjacet odes (b, c, ad e). update the values of pat h_weight (to 5, 3, ad 2) ad previous (to a) ad the remove a from remaiig. 2. The, we go to the ext smallest ode, which is e. We previously updated pat h_weight [ e] to be 2. Its adjacet odes are h ad i, so we update pat h_weight (to 6 ad 9) ad pre vious for both of those. 634 I Crackig the Codig Iterview, 6th Editio

9 XI. Advaced Topics Observe that 6 is path_weight [ e] (which is 2) + the weight of the edge ( e, h) (which is 4). 3. The ext smallest ode is c, which has path_weight 3. Its adjacet odes are b ad d. The value of path_weight [ d] is ifiity, so we update it to 4 (which is path_weight [ c] + weight ( edge c, d). The value of path_weight[b] has bee previously set to 5. However, sice path_weight[c] + weight ( edge c, b) (which is = 4) is less tha 5, we update path_weight [ b] to 4 ad previous to c. This idicates that we would improve the path from a to b by goig through c. We cotiue doig this util remaiig is empty. The followig diagram shows the chages to the path_ weight (left) ad previous (right) at each step. The topmost row shows the curret value for (the ode we are removig from remaiig). We black out a row after it has bee removed from remaiig. INITIAL FINAL wt pr wt pr a 0 0 b 00 4 C C 00 3 a d 00 4 C e 00 2 a f 00 7 h g 00 6 d h 00 5 d 00 8 g Oce we're doe, we ca follow this chart backwards, startig at i to fid the actual path. I this case, the smallest weight path has weight 8 ad is a - > c - > d - > g - > i. Priority Queue ad Rutime As metioed earlier, our algorithm used a priority queue, but this data structure ca be implemeted i differet ways. The rutime of this algorithm depeds heavily o the implemetatio of the priority queue. Assume you have v vertices ad e odes. If you implemeted the priority queue with a array, the you would call remove_mi up to v times. Each operatio would take 0( v) time, so you'd sped 0( v 2 ) time i the remove_mi calls. Additioally, you would update the values of path_weight ad previous at most oce per edge, so that's 0( e) time doig those updates. Observe that e must be less tha of equal to v 2 sice you ca't have more edges tha there are pairs of vertices. Therefore, the total rutime is 0( v 2 ). If you implemeted the priority queue with a mi heap, the the remove_mi calls will each take 0( log v) time (as will isertig ad updatig a key). We will do oe remove_mi call for each vertex, so that's 0( v log v) (v vertices at 0( log v) time each). Additioally, o each edge, we might call oe update key or isert operatio,sothat'so(e log v).the total rutime iso((v + e) log v). Which oe is better? Well, that depeds. If the graph has a lot of edges, the v 2 will be close to e. I this case, you might be better off with the array implemetatio, as O ( v 2 ) is better tha O ( ( v + v 2 ) log v). However, if the graph is sparse, the e is much less tha v 2 I this case, the mi heap implemetatio may be better. CrackigTheCodiglterview.com I 6th Editio 635

10 XI. Advaced Topics Hash Table Collisio Resolutio Essetially ay hash table ca have collisios. There are a umber of ways of hadlig this. Chaiig with Liked Lists With this approach (which is the most commo), the hash table's array maps to a liked list of items. We just add items to this liked list. As log as the umber of collisios is fairly small, this will be quite efficiet. I the worst case, lookup is O ( ), where is the umber of elemets i the hash table. This would oly happe with either some very strage data or a very poor hash fuctio (or both). Chaiig with Biary Search Trees Rather tha storig collisios i a liked list, we could store collisios i a biary search tree. This will brig the worst-case rutime too(log ). I practice, we would rarely take this approach uless we expected a extremely ouiform distributio. Ope Addressig with Liear Probig I this approach, whe a collisio occurs (there is already a item stored at the desigated idex), we just move o to the ext idex i the array util we fid a ope spot. (Or, sometimes, some other fixed distace, like the idex + 5.) If the umber of collisios is low, this is a very fast ad space-efficiet solutio. Oe obvious drawback of this is that the total umber of etries i the hash table is limited by the size of the array. This is ot the case with chaiig. There's aother issue here. Cosider a hash table with a uderlyig array of size 100 where idexes 20 through 29 are filled (ad othig else). What are the odds of the ext isertio goig to idex 30?The odds are 10% because a item mapped to ay idex betwee 20 ad 30 will wid up at idex 30. This causes a issue called clusterig. Quadratic Probig ad Double Hashig The distace betwee probes does ot eed to be liear. You could, for example, icrease the probe distace quadratically. Or, you could use a secod hash fuctio to determie the probe distace. Rabi-Karp Substrig Search The brute force way to search for a substrig S i a larger strig B takes O ( s ( b- s)) time, where s is the legth of S ad bis the legth of B. We do this by searchig through the first b - s + 1 characters i B ad, for each, checkig if the ext s characters match S. The Rabi-Karp algorithm optimizes this with a little trick: if two strigs are the same, they must have the same hash value. (The coverse, however, is ot true. Two differet strigs ca have the same hash value.) Therefore, if we efficietly precompute a hash value for each sequece of s characters withi B, we ca fid the locatios of S i 0( b) time. We the just eed to validate that those locatios really do match S. For example, imagie our hash fuctio was simply the sum of each character (where space= 0, a= 1, b = 2, ad so o). If S is ear ad B = doe a re hearig me, we'd the just be lookig for sequeces where the sum is 24 (e +a+ r). This happes three times. For each of those locatios, we'd check if the strig really is ear. 636 Crackig the Codig Iterview, 6th Editio

11 XI. Advaced Topics char: d 0 e a r e h e a r i g m e code: sum of ext 3: If we computed these sums by doig hash ( 'doe' ), the hash ( 'oe ' ), the hash ( 'e a' ), ad so o, we would still be at 0( s ( b- s)) time. Istead, we compute the hash values by recogizig that hash ( 'oe ' ) hash ( 'doe' ) - code ( 'd ' ) + code(' '). This takes 0( b) time to compute all the hashes. You might argue that, still, i the worst case this will take 0( s ( b-s)) time sice may of the hash values could match. That's absolutely true-for this hash fuctio. I practice, we would use a better rollig hash fuctio, such as the Rabi figerprit. This essetially treats a strig like doe as a base 128 (or however may characters are i our alphabet) umber. hash('doe') = code('d') * code('o') * code('e') * 128 This hash fuctio will allow us to remove the d, shift the o ad e, ad the add i the space. hash('oe ') = (hash('doe') - code('d') * ) * code(' ') This will cosiderably cut dow o the umber of false matches. Usig a good hash fuctio like this will give us expected time complexity ofo( s + b ), although the worst case is 0( sb ). Usage o fthis algorithm comes up fairly frequetly i iterviews, so it's useful to kow that you ca idetify substrigs i liear time. AVL Trees A AVL tree is oe of two commo ways to implemet tree balacig. We will olyd iscuss isertios here, but you ca look up deletios separately if you're iterested. Properties A AVL tree stores i each ode the height of the subtrees rooted at this ode. The, for ay ode, we ca check if it is height balaced: that the height of the left subtree ad the height of the right subtree differ by o more tha oe. This prevets situatios where the tree gets too lopsided. balace() =.left.height -.right.height -1 <= balace() <= 1 Iserts Whe you isert a ode, the balace of some odes might chage to -2 or 2. Therefore, whe we "uwid" the recursive stack, we check ad fix the balace at each ode. We do this through a series of rotatios. Rotatios ca be either left or right rotatios. The right rotatio is a iverse of the left rotatio. CrackigTheCodiglterview.com I 6th Editio 637

12 XI. Advaced Topics RIGHT LEFT Depedig o the balace ad where the imbalace occurs, we fix it i a differet way. Case 1: Balace is 2. I this case, the left's height is two bigger tha the right's height. If the left side is larger, the left subtree's extra odes must be hagig to the left (as i LEFT LEFT SHAPE) or hagig to the right (as i LEFT RIGHT SHAPE). If it looks like the LEFT RIGHT SHAPE, trasform it with the rotatios below ito the LEFT LEFT SHAPE the ito BALANCED. If it looks likethe LEFT LEFT SHAPE already.just trasform it ito BALANCED. LEFT RIGHT SHAPE LEFT LEFT SHAPE BALANCED LEFT ROTATION ---. RIGHT ROTATION ---. Case 2: Balaceis-2. This case is the mirror image of the prior case. The tree will look like either the RIGHT LEFT SHAPE or the RIGHT RIGHT SHAPE. Perform the rotatios below to trasform it ito BALANCED. RIGHT LEFT SHAPE RIGHT RIGHT SHAPE BALANCED RIGHT ROTATION ---. I both cases, "balaced" just meas that the balace of the tree is betwee -1 ad 1. It does ot mea that the balace is 0. We recurse up the tree, fixig ay imbalaces. If we ever achieve a balace of Oo a subtree, the we kow that we have completed all the balaces. This portio of the tree will ot cause aother, higher subtree to have a balace of -2 or 2. If we were doig this o-recursively, the we could break from the loop Crackig the Codig Iterview, 6th Editio

13 XI. Advaced Topics Red-Black Trees Red-black trees (a type of self-balacig biary search tree) do ot esure quite as strict balacig, but the balacig is still good eough to esure 0( log N) isertios, deletios, ad retrievals.they require a bit less memory ad ca rebalace faster (which meas faster isertios ad removals), so they are ofte used i situatios where the tree wil I be modified frequetly. Red-black trees operate by eforcig a quasi-alteratig red ad black colorig (uder certai rules, described below) ad the requirig every path from a ode to its leaves to have the same umber of black odes. Doig so leads to a reasoably balaced tree. The tree below is a red-black tree (where the red odes are idicated with gray): Properties 1. Every ode is either red or black. 2. The root is black. 3. The leaves, which are NULL odes, are cosidered black. 4. Every red ode must have two black childre. That is, a red ode caot have red childre (although a black ode ca have black childre). 5. Every path from a ode to its leaves must have the same umber of black childre. Why It Balaces Property #4 meas that two red odes caot be adjacet i a path (e.g., paret ad child). Therefore, o more tha half the odes i a path ca be red. Cosider two paths from a ode (say, the root) to its leaves. The paths must have the same umber of black odes (property #5), so let's assume that their red ode couts are as differet as possible: oe path cotais the miimum umber of red odes ad the other oe cotais the maximum umber. Path 1 (Mi Red): The miimum umber of red odes is zero. Therefore, path 1 has b odes total. Path 2 (Max Red):The maximum umber of red odes is b, sice red odes must have black childre ad there are b black odes. Therefore, path 2 has 2b odes total. Therefore, eve i the most extreme case, the legths of paths caot differ by more tha a factor of two. That's good eough to esure a 0( log N) fid ad isert rutime. If we ca maitai these properties, we'll have a (sufficietly) balaced tree-good eough to esure 0( log N) isert ad fid, ayway. The questio the is how to maitai these properties efficietly. We'll oly discuss isertio here, but you ca look up deletio o your ow. CrackigTheCodiglterview.com I 6th Editio 639

14 XI. Advaced Topics Isertio Isertig a ew ode ito a red-black tree starts off with a typical biary search tree isertio. New odes are iserted at a leaf, which meas that they replace a black ode. New odes are always colored red ad are give two black leaf ( NULL) odes. Oce we've doe that, we fix ay resultig red-black property violatios. We have two possible violatios: Red violatios: A red ode has a red child (or the root is red). Black violatios: Oe path has more blacks tha aother path. The ode iserted is red. We did't chage the umber of black odes o ay path to a leaf, so we kow that we wo't have a black violatio. However, we might have a red violatio. I the special case that where the root is red, we ca always just tur it black to satisfy property 2, without violatig the other costraits. Otherwise, if there's a red violatio, the this meas that we have a red ode uder aother red ode. Oops! Let's call N the curret ode. Pis N's paret. G is N's gradparet. U is N's ucle ad P's siblig. We kow that: N is red ad P is red, sice we have a red violatio. G is defiitely black, sice we did't previously have a red violatio. The ukow parts are: U could be either red or black. U could be either a left or right child. N could be either a left or right child. By simple combiatorics, that's eight cases to cosider. Fortuately some of these cases will be equivalet. Case 1 : U is red. It does't matter whether U is a left or right child, or whether Pis a left or right child. We ca merge four of our eight cases ito oe. If U is red, we ca just toggle the colors of P, U, ad G. Flip G from black to red. Flip P ad U from red to black. We have't chaged the umber of black odes i ay path. However, by makig G red, we might have created a red violatio with G's paret. If so, we recursively apply the full logic to hadle a red violatio, where this G becomes the ew N. Note that i the geeral recursive case, N, P, ad U may also have subtrees i place of each black NULL (the leaves show). I Case 1, these subtrees stay attached to the same parets, as the tree structure remais uchaged. 640 Crackig the Codig Iterview, 6th Editio

15 XI. Advaced Topics Case 2: U is black. We'll eed to cosider the cofiguratios (left vs. right child) of N ad U. I each case, our goal is to fix up the red violatio (red o top of red) without:» Messig up the orderig of the biary search tree.» Itroducig a black violatio (more black odes o oe path tha aother). If we ca do this, we're good. I each of the cases below, the red violatio is fixed with rotatios that maitai the ode orderig. Further, the below rotatios maitai the exact umber of black odes i each path through the affected portio of the tree that were i place beforehad. The childre of the rotatig sectio are either NULL leaves or subtrees that remai iterally uchaged. Case A: N ad Pare both left childre. We resolve the red violatio with the rotatio of N, P. ad G ad the associated recolorig show below. If you picture the i-order traversal, you ca see the rotatio maitais the ode orderig (a <= N < = b <= P <= c <= G <= U). The tree maitais the same, equal umber of black odes i the path dow to each subtree a, b, c, ad U (which may all be NULL). Case 8: Pis a left child, ad N is a right child. The rotatios i Case B resolve the red violatio ad maitai the i-order property: a < = P < = b < = N < = c < = G < = U. Agai, the cout of the black odes remais costat i each path dow to the leaves (or subtrees). CrackigTheCodiglterview.com I 6th Editio 641

16 XI. Advaced Topics Case C: N ad Pare both right childre. This is a mirror image of case A. Case D: N is a left child, ad Pis a right child. This is a mirror image of case B. I each of Case 2's subcases, the middle elemet by value of N, P, ad G is rotated to become the root of what was G's subtree, ad that elemet ad G swap colors. That said, do ot try to just memorize these cases. Rather, study why they work. How does each oe esure o red violatios, o black violatios, ad o violatios of the biary search tree property? MapReduce MapReduce is used widely i system desig to process large amouts of data. As its ame suggests, a MapReduce program requires you to write a Map step ad a Reduce step. The rest is hadled by the system. 1. The system splits up the data across differet machies. 2. Each machie starts ruig the user-provided Map program. 3. The Map program takes some data ad emits a <key, value> pair. 4. The system-provided Shuffle process reorgaizes the data so that all <key, value> pairs associated with a give key go to the same machie, to be processed by Reduce. 5. The user-provided Reduce program takes a key ad a set of associated values ad "reduces" them i some way, emittig a ew key ad value. The results of this might be fed back ito the Reduce program for more reducig. The typical example of usig MapReduce-basically the "Hello World" of MapReduce-is coutig the frequecy of words withi a set of documets. 642 Crackig the Codig Iterview, 6th Editio

17 XI. Advaced Topics Of course, you could write this as a sigle fuctio that reads i all the data, couts the umber of times each word appears via a hash table, ad the outputs the result. MapReduce allows you to process the documet i parallel. The Map fuctio reads i a documet ad emits just each idividual word ad the cout (which is always 1). The Reduce fuctio reads i keys (words) ad associated values (couts). It emits the sum of the couts. This sum could possibly wid up as iput for aother call to Reduce o the same key (as show i the diagram). 1 void map(strig ame, Strig documet) : 2 for each word w i documet : 3 emit(w, 1) 4 5 void reduce(strig word, Iterator partialcouts ): 6 it sum = 0 7 for each cout i partialcouts : 8 sum += cout 9 emit(word, sum) The diagram below shows how this might work o this example. at do go do go at Spl it Map )at, do, EL do g lgq. go, go o -cro g-. do, go o g.o. a1 g go Here's aother example: You have a list of data i the form {City, Temperature, Date}. Calculate the average temperature i each city every year. For example ((2012, Philadelphia, 58.2). (2011, Philadelphia, 56.6), (2012, Seattle, 45.1 )}. Map: The Map step outputs a key value pair where the key is City _Ye ar ad the value is ( Tempe rature, 1). The'l' reflects that this is the average temperature out of oe data poit.this will be importat for the Reduce step. Reduce: The Reduce step will be give a list of temperatures that correspod with a particular city ad year. It must use these to compute the average temperature for this iput. You caot simply add up the temperatures ad divide by the umber of values. To see this, imagie we have five data poits for a particularcity ad year: 25, 100, 75, 85, 50. The Reduce step might oly get some of this data at oce. If you averaged (75, 85} you would get 80. This might ed up beig iput for aother Reduce step with 50, ad it would be a mistake to just aively average80 ad 50. The 80 has more weight. Therefore, our Reduce step istead takes i ((80, 2), (50, 1 }}, the sums the weighted temperatures. So it does 80 * * 1 ad the divides by (2 + 1) to get a average temperature of 70. It the emits (70, 3). Aother Reduce step might reduce ((25, 1 ), ( 100, 1)} to get (62.5, 2). If we reduce this with (70, 3) we get the fial aswer: (67, 5). I other words, the average temperature i this city for this year was 67 degrees. We could do this i other ways, too. We could have just the city as the key, ad the value be (Year, Temperature, Cout). The Reduce step would do essetially the same thig, but would have to group by Year itself. CrackigTheCodiglterview.com I 6th Editio 643

18 XI. Advaced Topics I may cases, it's useful to thik about what the Reduce step should do first, ad the desig the Map step aroud that. What data does Reduce eed to have to do its job? Additioal Studyig So, you've mastered this material ad you wat to lear eve more? Okay. Here are some topics to get you started: Bellma-Ford Algorithm: Fids the shortest paths from a sigle ode i a weighted directed graph with positive ad egative edges. Floyd-Warshall Algorithm: Fids the shortest paths i a weighted graph with positive or egative weight edges (but o egative weight cycles). Miimum Spaig Trees: I a weighted, coected, udirected graph, a spaig tree is a tree that coects all the vertices. The miimum spaig tree is the spaig tree with miimum weight. There are various algorithms to do this. B-Trees: A self-balacig search tree (ot a biary search tree) that is commoly used o disks or other storage devices. It is similar to a red-black tree, but uses fewer 1/0 operatios. A*: Fid the least-cost path betwee a source ode ad a goal ode (or oe of several goal odes). It exteds Dijkstra's algorithm ad achieves better performace by usig heuristics. Iterval Trees: A extesio of a balaced biary search tree, but storig itervals (low -> high rages) istead of simple values. A hotel could use this to store a list of all reservatios ad the efficietly detect who is stayig at the hotel at a particular time. Graph colorig: A way of colorig the odes i a graph such that o two adjacet vertices have the same color. There are various algorithms to do thigs like determie if a graph ca be colored with oly K colors. P, NP, ad NP-Complete: P, NP, ad NP-Complete refer to classes of problems. P problems are problems that ca be quickly solved (where "quickly" meas polyomial time). NP problems are those where, give a solutio, the solutio ca be quickly verified. NP-Complete problems are a subset of NP problems that ca all be reduced to each other (that is, if you foud a solutio to oe problem, you could tweak the solutio to solve other problems i the set i polyomial time). It is a ope (ad very famous) questio whether P = NP, but the aswer is geerally believed to be o. Combiatorics ad Probability: There are various thigs you ca lear about here, such as radom variables, expected value, ad -choose-k. Bipartite Graph: A bipartite graph is a graph where you ca divide its odes ito two sets such that every edge stretches across the two sets (that is, there is ever a edge betwee two odes i the same set). There is a algorithm to check if a graph is a bipartite graph. Note that a bipartite graph is equivalet to a graph that ca be colored with two colors. Regular Expressios: You should kow that regular expressios exist ad what they ca be used for (roughly). You ca also lear about how a algorithm to match regular expressios would work. Some of the basic sytax behid regular expressios could be useful as well. There is of course a great deal more to data structures ad algorithms. If you're iterested i explorig these topics more deeply, I recommed pickig up the hefty Itroductio to Algorithms ("CLRS" by Carme, Leiserso, Rivest ad Stei) or The Algorithm Desig Maual (by Steve Skiea). 644 j Crackig the Codig Iterview, 6th Editio