CHAIN MATRIX MULTIPLICATION פנוש אורי וגיא בן-חורין
CHAIN MATRIX MULTIPLICATION חזרה קצרה על הכפלת מטריצות הגדרת בעיית הכפלת שרשרת מטריצות פתרון רקורסיבי לבעיה ייעול הפתרון הרקורסיבי ע"י memoization הצגת פתרון יעיל יותר ע"י תכנון דינאמי
חזרה על הכפלת מטריצות
REVIEW OF MATRIX MULTIPLICATION 1 0 2 1 0 1 1 * 2 0 0 1*1 2*2 0*0 1 0*1 1*2 1*0 2 5 2 2 1 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
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]
MATRIX-CHAIN MULTIPLICATION הבעיה: בהינתן המטריצות A 1, A 2,,A n נרצה לחשב את המכפלה A 1 x A 2 x. X A n ע "י מספר מינימאלי של הכפלות ולהחזיר את הסידור שהביא אותנו לתוצאה זו. בעצם, אנחנו מחפשים סידור אופטימאלי )לפיו נכפול את המטריצות( שיתן לנו את מס' הפעולות )הכפלות( המינימאלי. *
MATRIX-CHAIN MULTIPLICATION (CONT.) דוגמא: נרצה להכפיל את המטריצות A x B x C x D 30 x 1 1 x 40 40 x 10 10 x 25 החישוב הבא מראה לנו כמה הכפלות נאלץ לעשות לפי כל אחד מהסידורים האפשריים של המטריצות : ((AB)C)D 30x1x40 + 30x40x10 + 30x10x25 = 20,700 A(B(CD)) 40x10x25 + 1x40x25 + 30x1x25 = 11,750 (AB)(CD) 30x1x40 + 40x10x25 + 30x40x25 = 41,200 A((BC)D) 1x40x10 + 1x10x25 + 30x1x25 = 1400
DOES THE GREEDY APPROACH WORK? in our example - A x B x C x D 30 x 1 1 x 40 40 x 10 10 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
DOES THE GREEDY APPROACH WORK? in an even simpler example, No. A 1 * A 2 * A 3 30x1 1x40 40x50 Greedy approach gives 30x1x40 + 30x40x50= 61200 Optimal answer is 1x40x50 + 30x1x50 = 3500
הפתרון הרקורסיבי
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 : 13 5 89 3 34 דוגמא: )הגדרה: ) 4 cost(a 1 A 2 A 3 A הינו מספר ההכפלות המינימאלי לחישוב המכפלה הנ"ל.
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,078 + 15,130 + 2,210 = 26,418 A 1 A 2 A 3 A 4 13 5 89 3 34 (A 1 (A 2 (A 3 A 4 ))), costs = 26418 (A 1 ((A 2 A 3 )A 4 )), costs = 4055 ((A 1 A 2 )( A 3 A 4 )), costs = 54201 ((A 1 (A 2 A 3 ))A 4 ), costs = 2856 ((( A 1 A 2 )A 3 )A 4 ), costs = 10582
(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 A4 1 2 3 2 1 3 A 1 A 2 A 3 A 4
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
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 ).
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
SUBPROBLEM OVERLAP 1..4 1..1 2..4 1..2 3..4 1..3 4..4 2..2 3..4 2..3 4..4 1..1 2..2 3..3 4..4 3..3 4..4 2..2 3..3 1..1 2..3 1..2 3..3 חישובים כפולים!!! 2..2 3..3 1..1 2..2 ולכן, זמן החישוב הינו אקספוננציאלי!
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 הכפלות, כלומר, מצאנו פתרון יותר טוב מהפתרון האופטימאלי עליו הסתכלנו בהתחלה סתירה לאופטימאליות הפתרון ההתחלתי
ייעול הפתרון הרקורסיבי ע"י memoization
DYNAMIC PROGRAMMING ALGORITHM מכיוון שישנן כפילויות רבות של חישובים, נשתמש ב- memoization. כל תת-פתרון שנחשב "ייזכר" בתא מתאים בטבלה ולפני חישוב כל ערך נבדוק האם הוא כבר חושב )משמע, נמצא בטבלה( או לא.
SUBPROBLEM OVERLAP RecursiveMatrixChain(S, i, j): אלגוריתם: קלט : רצף S של n מטריצות להכפלה פלט: מס' ההכפלות שצריך לבצע בפתרון אופטימאלי של S * בתחילת הריצה, כל תאי המטריצה מאותחלים ל.
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
SUBPROBLEM OVERLAP נזכור את החישובים הכפולים ממקודם: 1..4 1..1 2..4 1..2 3..4 1..3 4..4 2..2 3..4 2..3 4..4 1..1 2..2 3..3 4..4 3..3 4..4 2..2 3..3 1..1 2..3 1..2 3..3 2..2 3..3 1..1 2..2
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 1 2 3 4 1..4 1..2 3..4 דוגמת ריצה: 1 2 3 4 + 0 10x4x5 + 200 160+10x4x8 480 + 120+10x4x2 + 200 + + + + 0 4x5x8 160 + 80 + 120 + 4x5x2 + + 0 5x8x2 + 80 N 1, 2, 3 4 min{480, min{200, min{120, 160 200 480 + 4x8x2} 80 10x5x8} 10x8x2} + 10x5x2} = 120 = 480 200 = 200 + + 200 + 0 תשובה סופית: 200 10 4 5 8 2 d1 d2 d3 d4 d5 1..1 2..4 2..2 3..4 2..3 4..4 1..1 2..2 3..3 4..4 1..1 1..3 4..4 2..3 3..3 4..4 2..2 3..3 2..2 3..3
הפסקה נעימה
פתרון ע"י תכנון דינאמי )איטרטיבי(
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
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)
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 0 1 2 i j n-1 0 1 i j n-1 answer
MCM DP Example S[1,6]=3 -> A A A A A 1 2 3 4 5A6
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 1 1 2 d1d3d d d d 4 d 5 5 5 0 2500 35*15* 20 13000, 2625 1000 35*5* 20 7125, 4375 0 35*10* 20 11375
אז עכשיו אנחנו יודעים מה מס' ההכפלות המינימאלי שידרשו לנו כדי להכפיל את שרשרת המטריצות. אבל איך נדע )נשחזר( את הסידור שהביא אותנו לתוצאה??
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
DYNAMIC PROGRAMMING ALGORITHM VISUALIZATION (A 0 *(A 1 *A 2 ))*((A 3 *A 4 )*A 5 )
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 } 1 2 3 4 5 6 1 0 30 64 132 226 348 2 0 24 72 156 268 3 0 72 198 366 4 0 168 392 5 0 336 6 0
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 1 2 3 4 5 6 1 1 1 1 1 1 2 2 3 4 5 3 3 4 5 4 4 5 5 5 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
ONE MORE EXAMPLE d = A 1 * A 2 * A 3 * A 4 30x1 1x40 40x10 10x25 30 1 40 10 25 0-1 1200 1 700 1 1400 1 m = s = 0-1 400 2 0-1 650 3 10000 3 0-1
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 ))
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.
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 )
That s what happens when you don t do the chain.