UVA-348 Optimal Array Multiplication Sequence

Description

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) andcolumns(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  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 XYZ we could either compute (XY) Z or X (YZ). 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:

(XY) Z

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

X (YZ)

•  multiplications to determine the product (YZ), a  array.
• Then  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  . 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))

这是一个矩阵链相乘问题，是个典型的dp问题。

问题描述：

两个矩阵A和B可以相乘当且仅当A的列数等于B的行数，一个m * p的矩阵乘以一个p * n的矩阵等于一个m * n的矩阵，运算量为mpn。

矩阵乘法不满足分配律，但满足结合律，A * B * C可以按顺序(A * B) * C,也可以是A * （B * C）假设A B C分别是 2 *3、3 * 4、4 * 5的则用第一种算法运算量为64，第二种运算量为90。

要解决的问题是给你n个矩阵，算出它们相乘所用的最少运算量。

思路描述：

运用dp思想。

定义计算A[i,j](第i个矩阵乘以第j个矩阵)所需要的最少次数为dp[i][j];则最优解就是dp[1][n];

我们可以知道当i = j时，即为矩阵本身，那么dp[i][j]= 0;

当i < j 时，可利用最优子结构性质计算dp[i][j],假设AiAi+1…Aj 的最优解在Ak和Ak+1之间分开，其中i <= k < j 则dp[i][j]等于计算子乘积dp[i][k]和dp[k][j]的和再加上两个矩阵相乘。(每个矩阵的维度是pi-1 * pi)

           dp[i][j] = dp[i][k] + dp[k+1][j] + pi-1 * pk * pj

然后我们判断k在每个断点，求出dp[i][j] 的最小值。

本题代码：

#include<stdio.h>
#include<math.h>
#include<string.h>
#include<algorithm>
#include<iostream>
using namespace std;

#define maxn 15
int s[maxn][maxn], n, l;
char ans[150];

void TraceBack(int i, int j)
{
    if(i==j)
    {
        ans[l++] = 'A';
        if(i == 10)
        {
            ans[l++] = '1';
            ans[l++] = '0';
        }
        else
            ans[l++] = i + '0';
    }
    else
    {
        ans[l++] = '(';
        TraceBack(i,s[i][j]);
        TraceBack(s[i][j]+1,j);
        ans[l++] = ')';
    }
}

int main()
{
    int p[maxn], dp[maxn][maxn];
    int i, temp, j, k, q = 1;
    while(scanf("%d",&n) && n)
    {
        for(i = 0; i < n; i++)
            scanf("%d%d",&p[i],&temp);//p数组储存每个矩阵的行
        if(n == 1)
        {
            printf("Case %d: ",q++);
            printf("(A1)\n");
            continue;
        }
        p[i] = temp; // 最后一个矩阵的列
        memset(dp,0,sizeof(dp));//初始化dp
        memset(s, 0, sizeof(s));
        for(i = 2; i <= n; i++) // 对角线，先从2号对角线开始填数。
        {
            for(j = 1; j <= n - i + 1; j++)//j是从第几个矩阵开始算
            {
                int t = j + i - 1;//t当前计算的最后一个矩阵，即对角线的最后一个元素
                dp[j][t] = dp[j + 1][t] + p[j-1] * p[j] * p[t];//先判断按顺序计算的值
                s[j][t] = j;
                for(k = j + 1; k < t; k++)//k代表断点处
                {
                    int r = dp[j][k] + dp[k+1][t] + p[j - 1] * p[k] * p[t];//计算从第k个断点处的值，
                    if(r < dp[j][t])
                    {
                        dp[j][t] = r;
                        s[j][t]  = k;
                    }
                }
            }
        }
        l = 0;
        printf("Case %d: ",q++);
        TraceBack(1,n);
        ans[l] = '\0';
        for(i = 0; i < l; i++)
        {
            printf("%c",ans[i]);
            if(ans[i] >= '0' && ans[i] <= '9')
            {
                if(ans[i + 1] == '0')
                    continue;
                if(ans[i + 1] != ')')
                    printf(" x ");
            }
            else if(ans[i] == ')')
            {
                if(ans[i + 1] == '(' || ans[i + 1] == 'A')
                    printf(" x ");
            }
        }
       // printf("%s",ans);
        printf("\n");
    }
    return 0;
}