最近開始刷奇奇神的dp專題，呃，我是弱菜，啥都不會，現在才開始刷dp，
在nocLyt神的熏陶下，覺著區間dp有些感覺了
不過還是調半天才調出來
今天做的這個
M - Optimal Array Multiplication Sequence
Time Limit:3000MS Memory Limit:0KB 64bit IO Format:%lld & %llu Description
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 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 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.
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.
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.
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
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，就放在這了，
#include<stdio.h>
#include<string.h>
#include<math.h>
#define inf 0x7ffffff
#define maxn 15
int f[maxn][maxn],path[maxn][maxn];
int l[maxn],r[maxn];
int n;
int min(int a,int b)
{
return a<b?a:b;
}
void print(int h,int t)
{
printf("(");
if (t-h==1)
{
printf("A%d x A%d",h,t);
}
else
{
int tmp=path[h][t];
if(tmp-h==0)
{
printf("A%d x ",h);
if(t-tmp-1==0) printf("A%d",t);else print(tmp+1,t);
}
else if(t-tmp==0)
{
if(h-tmp-1==0) printf("A%d",h);else print(h,tmp-1);
printf(" x A%d",t);
}
else
{
if(h-tmp==0) printf("A%d",h);else print(h,tmp);
printf(" x ");
if(t-tmp-1==0) printf("A%d",t);else print(tmp+1,t);
}
}
printf(")");
}
int main()
{
int i,j,k,times;
times=0;
while(scanf("%d",&n)!=EOF&&n!=0)
{
times++;
for(i=1; i<=n; i++) scanf("%d%d",&l[i],&r[i]);
memset(f,0,sizeof(f));
for(i=1; i<=n-1; i++)
f[i][i+1]=l[i]*r[i]*r[i+1];//,printf("%d %d %d\n",i,i+1,f[i][i+1]);
for(i=n-2; i>=1; i--)
{
for(j=i+2; j<=n; j++)
{
f[i][j]=inf;
for(k=i; k<=j; k++)
if(f[i][k]+f[k+1][j]+l[i]*r[k]*r[j]<f[i][j])
{
//printf("%d %d %d %d %d %d\n",i,k,j,f[i][k],f[k+1][j],l[i]*r[k]*r[j]);
f[i][j]=f[i][k]+f[k+1][j]+l[i]*r[k]*r[j];
path[i][j]=k;
}
//printf("%d %d %d %d\n",i,j,f[i][j],path[i][j]);
}
}
//printf("%d\n",f[1][n]);
printf("Case %d: ",times);
print(1,n);
printf("\n");
}
return 0;
}
呃，我是water，那個這個還可以用記憶化dp來實現，不過我沒寫過很好的記憶化搜索，干脆每次都寫的遞推實現
不過效率還好……