Optimal Array Multiplication Sequence - UVa 348 dp

最新推荐文章于 2018-09-26 19:06:47 发布

原创最新推荐文章于 2018-09-26 19:06:47 发布 · 540 阅读

0 ·

CC 4.0 BY-SA版权

dp动态规划和递推同时被 2 个专栏收录

281 篇文章

订阅专栏

UVa

218 篇文章

订阅专栏

本文探讨了在矩阵乘法中如何通过优化计算序列来减少乘法操作的数量，包括两个矩阵相乘的基本原理，以及如何在多矩阵相乘时选择最佳顺序以减少计算量。通过动态规划方法解决此问题，并提供了求解过程的详细步骤和示例。

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

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[i][j]表示第i个到第j个相乘的最少次数，然后就递推。

AC代码如下：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct node
{ int n,m;
}mat[15];
int n;
int dp[15][15];
void dfs(int l,int r)
{ int i,j;
  if(l==r)
  { printf("A%d",l);
    return;
  }
  if(l+1==r)
  { printf("(A%d x A%d)",l,r);
    return;
  }
  for(i=l;i<r;i++)
   if(dp[l][i]+dp[i+1][r]+mat[l].n*mat[i].m*mat[r].m==dp[l][r])
    break;
  printf("(");
  dfs(l,i);
  printf(" x ");
  dfs(i+1,r);
  printf(")");
}
int main()
{ int t=0,i,j,k;
  while(~scanf("%d",&n) && n)
  { for(i=1;i<=n;i++)
    { scanf("%d%d",&mat[i].n,&mat[i].m);
      dp[i][i]=0;
    }
    for(i=n;i>=1;i--)
     for(j=i+1;j<=n;j++)
     { dp[i][j]=1000000000;
       for(k=i;k<j;k++)
       dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+mat[i].n*mat[k].m*mat[j].m);
     }
    printf("Case %d: ",++t);
    dfs(1,n);
    printf("\n");
  }
}