d = <4, 10, 3, 12, 20, 7>, n = 5
length 2
  M[1,2] k=1: 0 + 0 + 4*10*3 = 120  <- best so far
  M[2,3] k=2: 0 + 0 + 10*3*12 = 360  <- best so far
  M[3,4] k=3: 0 + 0 + 3*12*20 = 720  <- best so far
  M[4,5] k=4: 0 + 0 + 12*20*7 = 1680  <- best so far
length 3
  M[1,3] k=1: 0 + 360 + 4*10*12 = 840  <- best so far
  M[1,3] k=2: 120 + 0 + 4*3*12 = 264  <- best so far
  M[2,4] k=2: 0 + 720 + 10*3*20 = 1320  <- best so far
  M[2,4] k=3: 360 + 0 + 10*12*20 = 2760
  M[3,5] k=3: 0 + 1680 + 3*12*7 = 1932  <- best so far
  M[3,5] k=4: 720 + 0 + 3*20*7 = 1140  <- best so far
length 4
  M[1,4] k=1: 0 + 1320 + 4*10*20 = 2120  <- best so far
  M[1,4] k=2: 120 + 720 + 4*3*20 = 1080  <- best so far
  M[1,4] k=3: 264 + 0 + 4*12*20 = 1224
  M[2,5] k=2: 0 + 1140 + 10*3*7 = 1350  <- best so far
  M[2,5] k=3: 360 + 1680 + 10*12*7 = 2880
  M[2,5] k=4: 1320 + 0 + 10*20*7 = 2720
length 5
  M[1,5] k=1: 0 + 1350 + 4*10*7 = 1630  <- best so far
  M[1,5] k=2: 120 + 1140 + 4*3*7 = 1344  <- best so far
  M[1,5] k=3: 264 + 1680 + 4*12*7 = 2280
  M[1,5] k=4: 1080 + 0 + 4*20*7 = 1640
  M         1      2      3      4      5
   1        0    120    264   1080   1344
   2        -      0    360   1320   1350
   3        -      -      0    720   1140
   4        -      -      -      0   1680
   5        -      -      -      -      0
  c         1      2      3      4      5
   1        -      1      2      2      2
   2        -      -      2      2      2
   3        -      -      -      3      4
   4        -      -      -      -      4
   5        -      -      -      -      -
  least cost M[1,5] = 1344, bracketing ((A1A2)((A3A4)A5))

Memoization against plain recursion on the same chain
  plain recursion : cost 1344 after 81 calls
  memoized        : cost 1344 after 41 calls

Growth of the call counts (dimensions do not matter for the count)
   n   plain recursion   memoized
   5                81         41
   8              2187        169
  11             59049        441
  14           1594323        911
  17          43046721       1633

Check yourself
d = <2, 3, 6, 4, 5>, n = 4
  M         1      2      3      4
   1        0     36     84    124
   2        -      0     72    132
   3        -      -      0    120
   4        -      -      -      0
  c         1      2      3      4
   1        -      1      2      3
   2        -      -      2      3
   3        -      -      -      3
   4        -      -      -      -
  least cost M[1,4] = 124, bracketing (((A1A2)A3)A4)
