UVa 348 Optimal Array Multiplication Sequence

 Optimal Array Multiplication Sequence 

Given two arrays A and B, we can determine the array C = A B 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 Ais a  array, and B is a  array, it will take  , 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 X Y Z we could either compute (X Y) Z or X (Y Z). Suppose X is a array, Y is a  array, and Z is a  array. Let's look at the number of multiplications required to compute the product using the two different sequences:

(X Y) Z

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

X (Y Z)

•  multiplications to determine the product (Y Z), a  array.
• Then  multiplications to determine the final result.
• Total multiplications: 8750.

Clearly we'll be able to compute (X Y) 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  . 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.

Sample Input

3
1 5
5 20
20 1
3
5 10
10 20
20 35
6
30 35
35 15
15 5
5 10
10 20
20 25
0

Sample Output

Case 1: (A1 x (A2 x A3))
Case 2: ((A1 x A2) x A3)
Case 3: ((A1 x (A2 x A3)) x ((A4 x A5) x A6))

给一些矩阵，求这些矩阵相乘所需的最少乘法次数。

设每个矩阵的行数保存在matrix_a[]中，列数保存在matrix_b[]中

动态规划，设dp[i][j]表示从第i个矩阵乘到第j个矩阵所需的的最少乘法次数

状态转移方程：dp[i][j]=min{ dp[i][k]+dp[k+1][j]+matrix_a[i]*matrix_b[k]*matrix_b[j] | i≤k≤j }

此题难点在于最终输出时的括号和格式，我的做法是，在动态规划的过程中先记录分割点，比如dp[i][j]是由dp[i][k]和dp[k+1][j]转移过来的，那么就令pos[i][j]=k。在动态规划结束后进行一次dfs，统计出各个矩阵左右的括号数。输出时依次输出各个矩阵左边的左括号数、矩阵Ai、右边的右括号数即可，中间用" x "间隔。

#include<iostream>
#include<cstdio>
#include<cstring>
#define INF 0x7fffffffffffffff

using namespace std;

int n;
int pos[15][15];
int left_pare[15],right_pare[15];
long long matrix_a[15],matrix_b[15];
long long dp[15][15];

void dfs(int x,int y)
{
    if(x==y)
        return ;

    left_pare[x]++;
    right_pare[y]++;

    if(x==y-1)
        return ;

    dfs(x,pos[x][y]);
    dfs(pos[x][y]+1,y);
}


int main()
{
    int kase=0;

    while(scanf("%d",&n)==1&&n)
    {
        for(int i=1;i<=n;i++)
            scanf("%lld %lld",&matrix_a[i],&matrix_b[i]);

        kase++;
        memset(dp,0,sizeof(dp));
        memset(pos,-1,sizeof(pos));

        for(int i=1;i<n;i++)
            dp[i][i+1]=matrix_a[i]*matrix_a[i+1]*matrix_b[i+1];
        for(int j=2;j<n;j++)
            for(int i=1;i<=n-j;i++)
            {
                long long Min=INF;
                for(int k=0;k<j;k++)
                {
                    long long temp=dp[i][i+k]+dp[i+k+1][i+j]+matrix_a[i]*matrix_b[i+k]*matrix_b[i+j];
                    if(temp<Min)
                    {
                        Min=temp;
                        pos[i][i+j]=i+k;
                    }
                }
                dp[i][i+j]=Min;
            }

        memset(left_pare,0,sizeof(left_pare));
        memset(right_pare,0,sizeof(right_pare));

        dfs(1,n);

        printf("Case %d: ",kase);
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=left_pare[i];j++)
                putchar('(');
            printf("A%d",i);
            for(int j=1;j<=right_pare[i];j++)
                putchar(')');
            if(i!=n)
                printf(" x ");
        }
        printf("
");
    }

    return 0;
}