CHAIN MATRIX MULTIPLICATION

פנושאורי

חורין-וגיא בן

CHAIN MATRIX MULTIPLICATION

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

הגדרת בעיית הכפלת שרשרת מטריצות •

פתרון רקורסיבי לבעיה •

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

י תכנון דינאמי"הצגת פתרון יעיל יותר ע •

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

REVIEW OF MATRIX MULTIPLICATION

12

25

2*11*10*00*12*11*0

2*01*20*10*02*21*1

20

12

01

*110

021

' למסחייב להיות שווה השורות במטריצה השמאלית ' מס• הטורים במטריצה הימנית

:ינה אסוציאטיביתההכפלת מטריצות •

(A1 x A2 ) x A3 = A1 x (A2 x A3 )

:הכפלת מטריצות אינה קומוטטיבית•

A1 x A2 != A2 x A1

MATRIX CHAIN-PRODUCTS

C = A*B

A is d × e and B is e × f

O(def ) time

A C

B

d d

f

e

f

e

i

j

i,j

1

0

],[*],[],[e

k

jkBkiAjiC

MATRIX-CHAIN MULTIPLICATION

:הבעיה

A1, A2, …,Anבהינתן המטריצות

A1 x A2 x …. X Anהמכפלה נרצה לחשב את

מספר מינימאלי של הכפלותי "ע

.שהביא אותנו לתוצאה זו הסידורולהחזיר את

לפיו נכפול)אנחנו מחפשים סידור אופטימאלי , בעצם*

( הכפלות)הפעולות ' לנו את מס שיתן( את המטריצות . המינימאלי

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.

A1 * A2 * A3

30x1 1x40 40x50

Greedy approach gives 30x1x40 + 30x40x50= 61200

Optimal answer is 1x40x50 + 30x1x50 = 3500

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

DATA VARIABLES

, נשים לב כי איננו צריכים את הערכים שבתוך המטריצות*

.אלא רק את הגדלים של המטריצות

.יהיה המערך שישמור לנו את הגדלים של המטריצות d[0..j]*

'וכו d[1] x d[2] הוא A2 הגודל של , d[0] x d[1] הוא A1 הגודל של *

d[i-1]*d[i]*d[i+1] היא : Ai Ai+1 * של ( ההכפלות' מס)העלות

דוגמא:

A1 A2 A3 A4

di : 13 5 89 3 34

cost(A1 A2 A3 A4 ) :הגדרה)

.ל"לחישוב המכפלה הנ הינו מספר ההכפלות המינימאלי

(A1(A2(A3A4))), costs = 26418

(A1((A2A3)A4)), costs = 4055

((A1A2 )( A3A4)), costs = 54201

((A1(A2 A3))A4), costs = 2856

((( A1A2)A3)A4), costs = 10582

A1 A2 A3 A4 13 5 89 3 34

Cost ((A1 x (A2 x (A3 x A4)))) :

Cost(A3 x A4) = d[2] x d[3] x d[4] = 89*3*34 = 9,078= A3A4

Cost(A2 x A3A4) = d[1] x d[2] x d[4] = 5*89*34 = 15,130 = A2A3A4

Cost(A1 x A2A3A4) = d[0] x d[1] x d[4] = 13*5*34 = 2,210 = A1A2A3A4

Cost ((A1 x (A2 x (A3 x A4)))) = 9,078 + 15,130 + 2,210 =

26,418

(A1(A2(A3A4)))

(A1((A2A3)A4))

((A1A2 )( A3A4))

((A1(A2 A3))A4)

((( A1A2)A3)A4)

A1 A2 A3 A4

2

1 3

A1 A2 A3 A4

1 2 3

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) + di-1dkdj]

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 -

j<i if}],1[],[{min

j=i if0],[

1j<ki

jki pppjkmkimjim

k T :

• If T is an optimal solution for A1, A2, … , An

1, …, k k+1, …, n

T1 T2

• then, T1 (resp. T2) is an optimal solution for A1,

A2, … , Ak (resp. Ak+1, Ak+2, … , An).

SUBPROBLEM OVERLAP

RecursiveMatrixChain(S, i, j): :אלגוריתם

S של n מטריצות להכפלה רצף : קלט

S ההכפלות שצריך לבצע בפתרון אופטימאלי של ' מס: פלט

. כל תאי המטריצה מאותחלים ל , בתחילת הריצה*

if i=j

then return 0

for k i to j do

Ni, j min{Ni,j, RecursiveMatrixChain(S, i ,k)+ RecursiveMatrixChain(S, k+1,j)+ pi pk+1 pj+1}

return Ni,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 3..3 4..4 1..1 2..2

3..3 4..4 2..2 3..3

3..3 1..2

1..1 2..2

2..3

2..2 3..3

1..1

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

PROOF

: המבנה של פיתרון אופטימאלי הוא*

בנפרד ולולכן הפיתרון האופטימאלי מצריך מציאת פתרון אופטימאלי ל

.ואז לחבר אותם ביחד

הוכחה: נסתכל על פתרון אופטימאלי כלשהו. נניח בשלילה כי הוא אינו פותר אופטימאלית

, ההכפלות הנדרש כדי לחשב את ' הוא מס X נניח כי . את

ההכפלות הנדרש' מס z y -ההכפלות הנדרש כדי לחשב את ו' הוא מס

(.הכפלת שתי תתי המטריצות)כדי לחשב את השלב האחרון באלגוריתם

x + y + z : ההכפלות הנדרש כדי לפתור את הבעיה הינו' מס

מכיוון שהפתרון אינו פותר אופטימאלית את קיים פתרון אופטימאלי שכן פותר אותה

אם נשתמש בפתרון הזה כדי לפתור את הבעיה נגיע. הכפלות x‟ < x י "אופטימאלית ע

מצאנו פתרון יותר טוב מהפתרון, כלומר, הכפלות x „ + y + z < x + y + z לפתרון של

האופטימאלי עליו הסתכלנו בהתחלה סתירה לאופטימאליות הפתרון ההתחלתי

n1iA1iA

n1ii21 A...AA...AA

n11A

iA1iA1

iA1

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

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 (Ni, k < +)

RC = Ni, k

else

RC = RecursiveMatrixChain(S, i ,k)

Ni, k = RC

if (Nk+1,j < +)

LC = Nk+1,j

else

LC = RecursiveMatrixChain(S, k+1,j)

Nk+1,j = LC

Ni, j min{Ni,j, RC + LC + di dk+1 dj+1}

return Ni,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 3..3 4..4 1..1 2..2

3..3 4..4 2..2 3..3

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

3..3 1..2

1..1 2..2

2..3

2..2 3..3

1..1

RECURSIVEMATRIXCHAIN(S, 1 ,4): דוגמת ריצהif i=j

return 0

for k i to j-1 do

if (Ni, k < +)

RC = Ni, k

else

RC = RecursiveMatrixChain(S, i ,k)

Ni, k = RC

if (Nk+1,j < +)

LC = Nk+1,j

else

LC = RecursiveMatrixChain(S, k+1,j)

Nk+1,j = LC

Ni, j min{Ni,j, RC + LC + di dk+1 dj+1}

return Ni,j

1..4

1..1 2..4

1..2 3..4

1..3 4..4

2..2 3..4 2..3 4..4

3..3 4..4 1..1 2..2

3..3 4..4 2..2 3..3

1 2 3 4

1

2

3

4

i=1, j=4 K=1 i=1, j=1 i=2, j=4 i=2, j=2 i=3, j=4 i=3, j=3 i=4, j=4 i=2, j=3 i=1, j=2 i=1, j=3 RC=0 LC=0

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

0

K=2

0

K=3

0

0

5x8x2

2..3 1..1

2..2 3..3

2 8 5 4 10

d1 d2 d3 d4 d5

LC=80

80

4x5x8

RC=160

160

LC=120

120+10x4x2 200 10x4x5

RC=200

200

N1, 4 min{200, 200 + 80 + 10x5x2} = 200

LC=160

160+10x4x8

N1, 3 min{480, 200 + 10x5x8} = 480

480

RC=480

N1, 4 min{200, 480 + 10x8x2} = 200

200: תשובה סופית

200

80 + 4x5x2 120

N2, 4 min{120, 160 + 4x8x2} = 120

הפסקה נעימה

י תכנון דינאמי"פתרון ע

(איטרטיבי)

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

Ni,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

Ni,j

for k i to j 1 do

Ni,j min{Ni,j, Ni,k + Nk+1,j + di dk+1 dj+1}

return N0,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)

answer

N 0 1

0

1

2 …

n-1

…

n-1 j

i

Dynamic Programming Algorithm Visualization

The bottom-up construction

fills in the N array by

diagonals

Ni,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(n3)

Getting actual optimal

solution can be done by

remembering “k” for each

N entry

}{min 11,1,,

jkijkkijki

ji dddNNN

i

j

MCM DP Example

S[1,6]=3 -> 654321 AAAAAA

DYNAMIC PROGRAMMING ALGORITHM

VISUALIZATION A0: 30 X 35; A1: 35 X15; A2: 15X5;

A3: 5X10; A4: 10X20; A5: 20 X 25

7125

}

1137520*10*3504375

,712520*5*3510002625

,1300020*15*3525000

min{

5414,43,1

5314,32,1

5214,21,1

4,1

dddNN

dddNN

dddNN

N

}{min 11,1,,

jkijkkijki

ji dddNNN

ההכפלות המינימאלי' אז עכשיו אנחנו יודעים מה מס

.שידרשו לנו כדי להכפיל את שרשרת המטריצות

(נשחזר)אבל איך נדע

??את הסידור שהביא אותנו לתוצאה

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

Ni,i 0 ; Tii 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

Ni,j ; Tij i;

for k i to j 1 do

If (Ni,j> Ni,k + Nk+1,j + di dk+1 dj+1)

Ti,jk

Ni,j min{Ni,j, Ni,k + Nk+1,j + di dk+1 dj+1}

return N0,n-1

נוסיף את טבלת

מקומות החלוקה

:שלנו לאלגוריתם

T -טבלת ה

DYNAMIC PROGRAMMING ALGORITHM

VISUALIZATION

(A0*(A1*A2))*((A3*A4)*A5)

Consider an example with sequence of dimensions

<5,2,3,4,6,7,8>

m[i, j] = mini k < j{m[i, k] + m[k+1, j] + pi1 pk pj }

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

EXAMPLE

m[i, j] = mini k < j{m[i, k] + m[k+1, j] + pi1 pk pj } 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

[1,6]

[2,6] A1

[2,5] A6

[2,4] A5

A4 [2,3]

A2 A3 A1(((( A2A3)A4)A5) A6)

ONE MORE EXAMPLE

A1 * A2 * A3 * A4

30x1 1x40 40x10 10x25

d =

m =

s =

30 1 40 10 25

0

-1

1200

1

700

1

1400

1

0

-1

400

2

650

3

0

-1

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 -

„(A1 x ((A2 x A3) x A4))‟

RUNNING TIME FOR DP PROGRAMS

#overall sub problems #choices.

We have to fill in n2/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(n2) O(n) = O(n3)

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 PI-1PKPJ.

Running time (n3)

Storage (n2)

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