矩阵连乘

//dp入门矩阵连乘  每个数乘的次数
//一个n*m 矩阵a[][] 与一个m*p 矩阵b[][]相乘生成 n*p矩阵c[][] 用了n*m*p次
//将这些矩阵不能打乱的，用括号划分每个可能的区域可以当成矩阵的右上三角
   

 (1,1)(1,2)(1,3)(1,4)(1,5)
      (2,2)(2,3)(2,4)(2,5)
   		   (3,3)(3,4)(3,5)
    			(4,4)(4,5)
    				 (5,5)

分得细点的dp[i][j] 每次更新dp是从左上到右下斜着来的

int dp[101][101],s[101][101];
void Matrics(int n)
{
    int i,j,k,len;
    for(i=1;i<=n;i++)
    {
        dp[i][i]=0;
    }
    for(len=2;len<=n;len++)//剩下n-1个
    {
        for(i=1;i<=n-len+1;i++)
        {
            j=i+len-1;
            dp[i][j]=dp[i][i]+dp[i+1][j]+p[i-1]*p[i]*p[j];//初始化随便一个分法
            s[i][j]=i;//记下划分的位置
            for(k=i+1;k<j;k++)
            {
                int t;
                t=dp[i][k]+dp[k+1][j]+p[i-1]*p[k]*p[j];
                if(t<dp[i][j])//找最优
                {
                    dp[i][j]=t;
                    s[i][j]=k;
                }
            }
        }
    }
}

粗糙的dp[i][j] 每次更新是从下到上横着来的

for(int i=n-1;i>=1;i--)
    {
        for(int j=i+1;j<=n;j++)
        {
            for(int k=i;k<j;k++)
            {
                dp[i][j]=max(dp[i][j],dp[i][k]+dp[k+1][j]+p[i-1]*p[k]*p[j];
            }
        }
    }

记忆化搜索
//dp就要倒着来(自底向上这样后面的才能用前面的),记忆化搜索就不用考虑

int Matrix(int i,int j)
{
    int k;
    if(dp[i][j]) return dp[i][j];
    dp[i][j]=inf;
    for(k=i;k<j;k++)
    {
        dp[i][j]=max(dp[i][j],Matrix(i,k)+Maxtrix(k+1,j)+p[i-1]*p[k]*p[j]);
    }
    return dp[i][j];
}