CHAIN MATRIX MULTIPLICATION וגיא בן-חורין

Transcript

1 CHAIN MATRIX MULTIPLICATION פנוש אורי וגיא בן-חורין

2 CHAIN MATRIX MULTIPLICATION חזרה קצרה על הכפלת מטריצות הגדרת בעיית הכפלת שרשרת מטריצות פתרון רקורסיבי לבעיה ייעול הפתרון הרקורסיבי ע"י memoization הצגת פתרון יעיל יותר ע"י תכנון דינאמי

3 חזרה על הכפלת מטריצות

4 REVIEW OF MATRIX MULTIPLICATION * *1 2*2 0*0 1 0*1 1*2 1* *0 2*1 0*2 0*0 1*1 1*2 מס' השורות במטריצה השמאלית חייב להיות שווה הטורים במטריצה הימנית למס' הכפלת מטריצות הינה אסוציאטיבית: (A 1 x A 2 ) x A 3 = A 1 x (A 2 x A 3 ) הכפלת מטריצות אינה קומוטטיבית: A 1 x A 2!= A 2 x A 1

5 MATRIX CHAIN-PRODUCTS f C = A*B B A is d e and B is e f O(d e f ) time e j e d A i C i,j d f C[ i, j] e 1 k 0 A[ i, k]* B[ k, j]

6 MATRIX-CHAIN MULTIPLICATION הבעיה: בהינתן המטריצות A 1, A 2,,A n נרצה לחשב את המכפלה A 1 x A 2 x. X A n ע "י מספר מינימאלי של הכפלות ולהחזיר את הסידור שהביא אותנו לתוצאה זו. בעצם, אנחנו מחפשים סידור אופטימאלי )לפיו נכפול את המטריצות( שיתן לנו את מס' הפעולות )הכפלות( המינימאלי. *

7 MATRIX-CHAIN MULTIPLICATION (CONT.) דוגמא: נרצה להכפיל את המטריצות A x B x C x D 30 x 1 1 x x x 25 החישוב הבא מראה לנו כמה הכפלות נאלץ לעשות לפי כל אחד מהסידורים האפשריים של המטריצות : ((AB)C)D 30x1x x40x x10x25 = 20,700 A(B(CD)) 40x10x25 + 1x40x x1x25 = 11,750 (AB)(CD) 30x1x x10x x40x25 = 41,200 A((BC)D) 1x40x10 + 1x10x x1x25 = 1400

8 DOES THE GREEDY APPROACH WORK? in our example - A x B x C x D 30 x 1 1 x x x 25 A x B = 30x1x40 = 1,200, B x C = 1x40x10 = 400, C x D = 40x10x25 = 10,000 B * C costs 400 Remaining is A * BC * D 30x1 1x10 10x25 A x BC = 30x1x10 = 300, BC x D = 1x10x25 = 250 Next do BC * D with cost of 250 Finally, A * BCD with cost of 750 Total cost = 1400 Yes

9 DOES THE GREEDY APPROACH WORK? in an even simpler example, No. A 1 * A 2 * A 3 30x1 1x40 40x50 Greedy approach gives 30x1x x40x50= Optimal answer is 1x40x x1x50 = 3500

10 הפתרון הרקורסיבי

11 DATA VARIABLES *נשים לב כי איננו צריכים את הערכים שבתוך המטריצות, אלא רק את הגדלים של המטריצות. d[0..j]* יהיה המערך שישמור לנו את הגדלים של המטריצות. * הגודל של A 1 הוא d[1], d[0] x הגודל של A 2 הוא d[2] d[1] x וכו ' *העלות )מס' ההכפלות( של i+1 A i A היא : d[i-1]*d[i]*d[i+1] A 1 A 2 A 3 A 4 d i : דוגמא: )הגדרה: ) 4 cost(a 1 A 2 A 3 A הינו מספר ההכפלות המינימאלי לחישוב המכפלה הנ"ל.

12 Cost ((A 1 x (A 2 x (A 3 x A 4 )))) : Cost(A 3 x A 4 ) = d[2] x d[3] x d[4] = 89*3*34 = 9,078= A 3 A 4 Cost(A 2 x A 3 A 4 ) = d[1] x d[2] x d[4] = 5*89*34 = 15,130 = A 2 A 3 A 4 Cost(A 1 x A 2 A 3 A 4 ) = d[0] x d[1] x d[4] = 13*5*34 = 2,210 = A 1 A 2 A 3 A 4 Cost ((A 1 x (A 2 x (A 3 x A 4 )))) = 9, , ,210 = 26,418 A 1 A 2 A 3 A (A 1 (A 2 (A 3 A 4 ))), costs = (A 1 ((A 2 A 3 )A 4 )), costs = 4055 ((A 1 A 2 )( A 3 A 4 )), costs = ((A 1 (A 2 A 3 ))A 4 ), costs = 2856 ((( A 1 A 2 )A 3 )A 4 ), costs = 10582

13 (A 1 (A 2 (A 3 A 4 ))) (A 1 ((A 2 A 3 )A 4 )) ((A 1 A 2 )( A 3 A 4 )) ((A 1 (A 2 A 3 ))A 4 ) ((( A 1 A 2 )A 3 )A 4 ) A1 A2 A3 A A 1 A 2 A 3 A 4

14 RECURSIVE FORMULATION OF SOLUTION m[i,j] = optimal cost for multiplying matrices i through j m(i,j) = min [m(i,k) + m(k+1,j) + d i-1 d k d j ] for 1 i j, i k j-1 m(i,i) = 0 m[1,n] = optimal cost for entire problem That s the way it looks - m[ i, j] 0 min{ m[ i, k] i k< j m[ k 1, j] p i 1 p k p j } if if i i = < j j

15 If T is an optimal solution for A 1, A 2,, A n T : k T 1 T 2 1,, k k+1,, n then, T 1 (resp. T 2 ) is an optimal solution for A 1, A 2,, A k (resp. A k+1, A k+2,, A n ).

16 SUBPROBLEM OVERLAP RecursiveMatrixChain(S, i, j): אלגוריתם: קלט : רצף S של n מטריצות להכפלה פלט: מס' ההכפלות שצריך לבצע בפתרון אופטימאלי של S * בתחילת הריצה, כל תאי המטריצה מאותחלים ל. if i=j then return 0 for k i to j do N i, j min{n i,j, RecursiveMatrixChain(S, i,k)+ RecursiveMatrixChain(S, k+1,j)+ p i p k+1 p j+1 } return N i,j

17 SUBPROBLEM OVERLAP חישובים כפולים!!! ולכן, זמן החישוב הינו אקספוננציאלי!

18 PROOF A 1i A *המבנה של פיתרון אופטימאלי הוא : 2...Ai Ai... 1 n ולכן הפיתרון האופטימאלי מצריך מציאת פתרון אופטימאלי ל ואז לחבר אותם ביחד. A בנפרד ול A i 1 n 1 A הוכחה: נסתכל על פתרון אופטימאלי כלשהו. נניח בשלילה כי הוא אינו פותר אופטימאלית את. נניח כי X הוא מס' ההכפלות הנדרש כדי לחשב את, y הוא מס' ההכפלות הנדרש כדי לחשב את ו- כדי לחשב את השלב האחרון באלגוריתם מס ' ההכפלות הנדרש כדי לפתור את הבעיה הינו : A 1i z מס' ההכפלות הנדרש )הכפלת שתי תתי המטריצות (. x + y + z A 1 1 n A 1i מכיוון שהפתרון אינו פותר אופטימאלית את A 1i קיים פתרון אופטימאלי שכן פותר אותה אופטימאלית ע "י x < x הכפלות. אם נשתמש בפתרון הזה כדי לפתור את הבעיה נגיע לפתרון של x + y + z < x + y + z הכפלות, כלומר, מצאנו פתרון יותר טוב מהפתרון האופטימאלי עליו הסתכלנו בהתחלה סתירה לאופטימאליות הפתרון ההתחלתי

19 ייעול הפתרון הרקורסיבי ע"י memoization

20 DYNAMIC PROGRAMMING ALGORITHM מכיוון שישנן כפילויות רבות של חישובים, נשתמש ב- memoization. כל תת-פתרון שנחשב "ייזכר" בתא מתאים בטבלה ולפני חישוב כל ערך נבדוק האם הוא כבר חושב )משמע, נמצא בטבלה( או לא.

21 SUBPROBLEM OVERLAP RecursiveMatrixChain(S, i, j): אלגוריתם: קלט : רצף S של n מטריצות להכפלה פלט: מס' ההכפלות שצריך לבצע בפתרון אופטימאלי של S * בתחילת הריצה, כל תאי המטריצה מאותחלים ל.

22 if i=j return 0 for k i to j-1 do if (N i, k < + ) RC = N i, k else RC = RecursiveMatrixChain(S, i,k) N i, k = RC if (N k+1,j < + ) LC = N k+1,j else LC = RecursiveMatrixChain(S, k+1,j) N k+1,j = LC N i, j min{n i,j, RC + LC + d i d k+1 d j+1 } return N i,j

23 SUBPROBLEM OVERLAP נזכור את החישובים הכפולים ממקודם:

24 i=3, i=4, i=2, i=1, j=1 j=4 j=2 j=3 K=1 K=2 K=3 RC=0 RC=160 RC=200 RC=480 LC=0 LC=80 LC=120 LC=160 RECURSIVEMATRIXCHAIN(S, 1,4) if i=j return 0 for k i to j-1 do if (N i, k < + ) RC = N i, k else RC = RecursiveMatrixChain(S, i,k) N i, k = RC if (N k+1,j < + ) LC = N k+1,j else LC = RecursiveMatrixChain(S, k+1,j) N k+1,j = LC N i, j min{n i,j, RC + LC + d i d k+1 d j+1 } return N i,j דוגמת ריצה: x4x x4x x4x x5x x5x x8x N 1, 2, 3 4 min{480, min{200, min{120, x8x2} 80 10x5x8} 10x8x2} + 10x5x2} = 120 = = תשובה סופית: d1 d2 d3 d4 d

25 הפסקה נעימה

26 פתרון ע"י תכנון דינאמי )איטרטיבי(

27 DYNAMIC PROGRAMMING ALGORITHM Algorithm matrixchain(s): Input: sequence S of n matrices to be multiplied Output: number of operations in an optimal parenthesization of S for i 1 to n 1 do N i,i 0 for b 1 to n 1 do { b j i is the length of the problem } for i 0 to n b - 1 do j i b N i,j for k i to j 1 do N i,j min{n i,j, N i,k + N k+1,j + d i d k+1 d j+1 } return N 0,n-1

28 MCM DP ORDER OF MATRIX COMPUTATIONS m(1,1) m(1,2) m(1,3) m(1,4) m(1,5) m(1,6) m(2,2) m(2,3) m(2,4) m(2,5) m(2,6) m(3,3) m(3,4) m(3,5) m(3,6) m(4,4) m(4,5) m(4,6) m(5,5) m(5,6) m(6,6)

29 Dynamic Programming Algorithm Visualization The bottom-up construction fills in the N array by diagonals N i,j gets values from previous entries in i-th row and j-th column Filling in each entry in the N table takes O(n) time. Total run time: O(n 3 ) Getting actual optimal solution can be done by remembering k for each N entry N min{ Ni, k Nk 1, j didk 1d j 1} i, j i k j N i j n i j n-1 answer

30 MCM DP Example S[1,6]=3 -> A A A A A A6

31 DYNAMIC PROGRAMMING ALGORITHM VISUALIZATION A 0 : 30 X 35; A 1 : 35 X15; A 2 : 15X5; A 3 : 5X10; A 4 : 10X20; A 5 : 20 X 25 N min{ Ni, k Nk 1, j didk 1d j 1} i, j i k j N N N N 1,4 1,1 1,2 1,3 } 7125 min{ N N N 2,4 3,4 4,4 d d d1d3d d d d 4 d *15* , *5* , *10*

32 אז עכשיו אנחנו יודעים מה מס' ההכפלות המינימאלי שידרשו לנו כדי להכפיל את שרשרת המטריצות. אבל איך נדע )נשחזר( את הסידור שהביא אותנו לתוצאה??

33 DYNAMIC PROGRAMMING ALGORITHM Algorithm matrixchain(s): Input: sequence S of n matrices to be multiplied Output: number of operations in an optimal parenthesization of S for i 0 to n 1 do N i,i 0 ; T ii i; for b 1 to n 1 do { b j i is the length of the problem } for i 0 to n b - 1 do j i b N i,j ; T ij i; for k i to j 1 do If (N i,j > N i,k + N k+1,j + d i d k+1 d j+1 ) T i,j k N i,j min{n i,j, N i,k + N k+1,j + d i d k+1 d j+1 } return N 0,n-1 נוסיף את טבלת מקומות החלוקה שלנו לאלגוריתם : טבלת ה -T

34 DYNAMIC PROGRAMMING ALGORITHM VISUALIZATION (A 0 *(A 1 *A 2 ))*((A 3 *A 4 )*A 5 )

35 EXAMPLE Consider an example with sequence of dimensions <5,2,3,4,6,7,8> m[i, j] = min i k < j {m[i, k] + m[k+1, j] + p i 1 p k p j }

36 m[i, j] = min i k < j {m[i, k] + m[k+1, j] + p i 1 p k p j } s[i, j] = a value of k that gives the minimum s A 1 (((( A 2 A 3 )A 4 )A 5 ) A 6 ) [1,6] A 1 [2,6] [2,5] [2,4] A 5 [2,3] A 2 A 3 A 4 A6

37 ONE MORE EXAMPLE d = A 1 * A 2 * A 3 * A 4 30x1 1x40 40x10 10x m = s =

38 PSEUDOCODE TO PRINT void printparens(s, i, j){ if (i == j) print A i else print ( printparens (s, i, s[i,j]) printparens (s, s[i,j], j) print ) } For the factor table in previous example, the output of printparens(s,1,6) is - (A 1 x ((A 2 x A 3 ) x A 4 ))

39 RUNNING TIME FOR DP PROGRAMS #overall sub problems #choices. We have to fill in n 2 /2 entries of M. For each it finds the minimum of fewer than n expressions involving a few arithmetic operations. thus the total number of steps is - O(n 2 ) O(n) = O(n 3 ) Each call to printparens results in writing exactly one matrix number or [ x, (, ) ], so there are 2n 1 calls, and printparens takes Θ(n) time.

40 THE COST =COSTS OF SOLVING SUBPROBLEMS + COST OF MAKING CHOICE. CHOICE COST IS P I-1 P K P J. Running time (n 3 ) Storage (n 2 )

41 That s what happens when you don t do the chain.