UVa 348 Optimal Array Multiplication Sequence (DP 最优矩阵链乘)

题意   求给定数目矩阵的最优链乘  并输出路径

矩阵链乘在小白P170有讲解 也是经典的动态规划 有了转移方程题目就好做了   设d[i][j]为矩阵i到矩阵j的最优链乘 初始状态d[i][i]=0 k为i,j之间的一个矩阵    x[i],y[i]分别表示第i个矩阵的行和列 则有d[i][j]=min{d[i][k]+d[k+1][j]+x[i]*y[k]*y[j]}
感觉这题比较难的就是路径打印了 仔细观察一下结构 其实也不难 记录每个k值 直接递归就行了

#include<cstdio>  
#include<cstring>  
using namespace std;  
#define maxn 11  
#define INF 0x3f3f3f3f  
#define t dp(i,k)+dp(k+1,j)+x[i]*y[k]*y[j]  
int d[maxn][maxn],pre[maxn][maxn],x[maxn],y[maxn],n;  
int dp(int i,int j)  
{  
    if(d[i][j]<INF) return d[i][j];  
    for(int k=i; k<j; ++k)  
        if(d[i][j]>t)  
        {  
            d[i][j]=t;  
            pre[i][j]=k;  
        }  
    return d[i][j];  
}  
  
void print(int i,int j)  
{  
    int k=pre[i][j];  
    if(k)  
    {  
        printf("(");  
        print(i,k);  
        printf(" x ");  
        print(k+1,j);  
        printf(")");  
    }  
    else  
    {  
        printf("A%d",i);  
    }  
}  
  
int main()  
{  
    int k=1;  
    while(scanf("%d",&n),n)  
    {  
        memset(d,0x3f,sizeof(d));  
        memset(pre,0,sizeof(pre));  
        for(int i=1; i<=n; ++i)  
        {  
            scanf("%d%d",&x[i],&y[i]);  
            d[i][i]=0;  
        }  
        dp(1,n);  
        printf("Case %d: ",k);  
        print(1,n);  
        printf("\n");  
        k++;  
    }  
    return 0;  
}  

 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(Bcolumns(A). For example, if A is a tex2html_wrap_inline67 array, and B is a tex2html_wrap_inline71 array, it will taketex2html_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 XY, and Z are arrays, then to compute X Y Z we could either compute (X YZ or X (Y Z). Suppose Xis 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:

(X YZ

  • 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 (Y Z)

  • tex2html_wrap_inline133 multiplications to determine the product (Y Z), 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 (X YZ 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.

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))



  • 2
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
矩阵链乘问题是一个经典的动态规划问题,其目标是找到一种最优的方式来计算给定的一组矩阵的连乘积。这个问题可以通过动态规划算法来解决。 动态规划算法的基本思想是将问题分解成更小的子问题,并使用已知的信息来计算更大的问题。在矩阵链乘问题中,我们可以将问题分解成计算两个矩阵的乘积的子问题,并使用已知的信息来计算更大的问题。 具体来说,我们可以定义一个二维数组m,其中m[i][j]表示从第i个矩阵到第j个矩阵的最小计算代价。我们还可以定义一个二维数组s,其中s[i][j]表示从第i个矩阵到第j个矩阵最优计算次序。 接下来,我们可以使用以下递归公式来计算m和s: m[i][j] = 0 (i = j) m[i][j] = min{m[i][k] + m[k+1][j] + ri*ck*cm} (i <= k < j) 其中,ri和ci分别表示第i个矩阵的行数和列数,cm表示两个矩阵相乘的计算代价。 使用上述递归公式,我们可以计算出所有的m[i][j]和s[i][j]。最终,我们可以通过s数组来构造出最优的计算次序,并使用m数组来计算最小的计算代价。 下面是一个Python实现的例子: ```python def matrix_chain_order(p): n = len(p) - 1 m = [[0] * n for i in range(n)] s = [[0] * n for i in range(n)] for l in range(2, n+1): for i in range(n-l+1): j = i + l - 1 m[i][j] = float('inf') for k in range(i, j): q = m[i][k] + m[k+1][j] + p[i]*p[k+1]*p[j+1] if q < m[i][j]: m[i][j] = q s[i][j] = k return m, s def print_optimal_parens(s, i, j): if i == j: print("A{}".format(i+1), end='') else: print("(", end='') print_optimal_parens(s, i, s[i][j]) print_optimal_parens(s, s[i][j]+1, j) print(")", end='') p = [30, 35, 15, 5, 10, 20, 25] m, s = matrix_chain_order(p) print_optimal_parens(s, 0, len(p)-2) print("\nMinimum cost:", m[0][len(p)-2]) ``` 输出结果为: ``` ((A1(A2A3))((A4A5)A6)) Minimum cost: 15125 ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值