uva348 Optimal Array Multiplication Sequence

Given two arrays A and B, we can determine the array C = AB using the
standard definition of matrix multiplication:

The number of columns in the A array must be the same as the number of
rows in the B array. Notationally, let’s say that rows(A) and
columns(A) are the number of rows and columns, respectively, in the A
array. The number of individual multiplications required to compute
the entire C array (which will have the same number of rows as A and
the same number of columns as B) is then rows(A) columns(B)
columns(A). For example, if A is a tex2html_wrap_inline67 array, and B
is a tex2html_wrap_inline71 array, it will take tex2html_wrap_inline73
, or 3000 multiplications to compute the C array.

To perform multiplication of more than two arrays we have a choice of
how to proceed. For example, if X, Y, and Z are arrays, then to
compute XYZ we could either compute (XY) Z or X (YZ). Suppose X is a
tex2html_wrap_inline103 array, Y is a tex2html_wrap_inline67 array,
and Z is a tex2html_wrap_inline111 array. Let’s look at the number of
multiplications required to compute the product using the two
different sequences:

(XY) Z

tex2html_wrap_inline119 multiplications to determine the product (X Y), a tex2html_wrap_inline123 array.
Then tex2html_wrap_inline125 multiplications to determine the final result.
Total multiplications: 4500. 

X (YZ)

tex2html_wrap_inline133 multiplications to determine the product (YZ), a tex2html_wrap_inline139 array.
Then tex2html_wrap_inline141 multiplications to determine the final result.
Total multiplications: 8750. 

Clearly we’ll be able to compute (XY) Z using fewer individual
multiplications.

Given the size of each array in a sequence of arrays to be multiplied,
you are to determine an optimal computational sequence. Optimality,
for this problem, is relative to the number of individual
multiplications required.

Input

For each array in the multiple sequences of arrays to be multiplied
you will be given only the dimensions of the array. Each sequence will
consist of an integer N which indicates the number of arrays to be
multiplied, and then N pairs of integers, each pair giving the number
of rows and columns in an array; the order in which the dimensions are
given is the same as the order in which the arrays are to be
multiplied. A value of zero for N indicates the end of the input. N
will be no larger than 10.

Output

Assume the arrays are named tex2html_wrap_inline157 . Your output for
each input case is to be a line containing a parenthesized expression
clearly indicating the order in which the arrays are to be multiplied.
Prefix the output for each case with the case number (they are
sequentially numbered, starting with 1). Your output should strongly
resemble that shown in the samples shown below. If, by chance, there
are multiple correct sequences, any of these will be accepted as a
valid answer.

最优矩阵链乘模板题。
dp[i][j]=min(dp[i][l]+dp[l+1][j]+i.x * l.y * j.y)。
输出路径需要更新的时候记录一下切分点，递归即可。

#include<cstdio>
#include<cstring>
#define M(a) memset(a,0x42,sizeof(a))
struct str
{
    int x,y;
}a[15];
int dp[15][15],p[15][15];
void prt(int l,int r)
{
    if (l==r)
    {
        printf("A%d",l);
        return;
    }
    printf("(");
    prt(l,p[l][r]);
    printf(" x ");
    prt(p[l][r]+1,r);
    printf(")");
}
int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("1.txt","w",stdout);
    int i,j,k,l,m,n,x,y,z,cnt=0;
    while (scanf("%d",&n)&&n)
    {
        cnt++;
        M(dp);
        for (i=1;i<=n;i++)
          dp[i][i]=0;
        for (i=1;i<=n;i++)
          scanf("%d%d",&a[i].x,&a[i].y);
        for (k=1;k<=n;k++)
          for (i=1;i+k-1<=n;i++)
          {
            j=i+k-1;
            for (l=i;l<j;l++)
              if (dp[i][l]+dp[l+1][j]+a[i].x*a[l].y*a[j].y<dp[i][j])
              {
                dp[i][j]=dp[i][l]+dp[l+1][j]+a[i].x*a[l].y*a[j].y;
                p[i][j]=l;
              }
          }
        printf("Case %d: ",cnt);
        prt(1,n);
        printf("\n");
    }
}