dp[i][j] 第i个矩阵到第j个矩阵相乘的最小次数  k是分割点

蓝桥 算法提高  矩阵乘法

裸题，注意不能用min函数，会超时

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
const int N=1e3+10;
const int INF=0x3f3f3f3f;
typedef long long LL;
LL ans=0;
LL a[N];
LL dp[N][N];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<=n;++i)     //n+1个数      a[i-1]是第i个矩阵的行数 a[i]是第i个矩阵的列数
        scanf("%lld",&a[i]);
    memset(dp,INF,sizeof(dp));
    for(int i=1;i<=n;++i)
        dp[i][i]=0;
    for(int l=2;l<=n;++l)   //枚举矩阵链乘的长度
    {
        for(int i=1;i+l-1<=n;++i)
        {
            //枚举链乘起始位置
            int j=i+l-1;    //j为链的末尾
            for(int k=i;k<=j-1;++k)     //枚举分割点
            {
                LL q=dp[i][k]+dp[k+1][j]+a[i-1]*a[k]*a[j];
                if(q<dp[i][j])
                    dp[i][j]=q;
            }
        }
    }
    printf("%lld\n",dp[1][n]);
    return 0;

}

题意：直接拿样例1解释。如果先乘[2,1000],[1000,2]生成的矩阵是[2,2]，需要开4个单位的空间，

如果先乘[1000,2],[2,1000]生成的矩阵是[1000,1000],需要开1e6个单位的空间。

空间要等计算完才会释放，问怎样计算的顺序使得中间存储占用空间最小，最小是多少？

思路：显然这是一道最优矩阵链乘的变形。注意最后一次计算生成的空间不算中间存储。

设最后一次分割点是K，A_1，A_K是左边的矩阵，A_{K+1},A_n是右边的矩阵，那么这两个矩阵的存储空间为A_1的行*A_n的列

dp[1][n]=dp[1,k]+dp[k+1,n]+row[1]*column[n]

转移方程为dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+row[i]*column[j]) 

最后的结果是dp[1][n]-row[1]*column[n]

A了这道题之后希望比赛就此停止2333

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<vector>
#include<queue>
#include<stack>
#include<cstdlib>
#include<map>
#include<set>
using namespace std;
typedef long long LL;
const int N=3000;
const int INF=0x3f3f3f3f;
LL a[N];
int cnt;
LL dp[N][N];
int main()
{
    //freopen("in.txt","r",stdin);
    string str;
    while(cin>>str)
    {
        int len=str.size();
        cnt=0;
        for(int i=0;i<len;++i)
        {
            if(str[i-1]=='['||str[i-1]==',')
            {
                int tmp=0;
                while(isdigit(str[i]))
                {
                    tmp=tmp*10+str[i]-'0';
                    i++;
                }
                a[cnt++]=tmp;
            }
        }
      
        int n=cnt/2;            //the number of matrix
        memset(dp,0,sizeof(dp));
        for(int len=2;len<=n;++len)     //n是总个数
        {
            for(int i=0;i+len-1<n;++i)
            {
                int j=i+len-1;
                dp[i][j]=INF;
                for(int k=i;k<j;++k)
                {
                
                    dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+a[2*i]*a[2*j+1]);
              
                }
            }
        }
        LL ans=dp[0][n-1]-a[0]*a[cnt-1];
        cout<<ans<<endl;
    }

    return 0;

}

蓝桥 算法提高 合并石子

题意：在一条直线上有n堆石子，每堆有一定的数量，每次可以将两堆相邻的石子合并，合并后放在两堆的中间位置，合并的费用为两堆石子的总数。求把所有石子合并成一堆的最小花费。

先考虑两个石子 最小花费就是他们的和

三个石子时，（a1a2）a3 sum=a1+a2+a1+a2+a3;   a1（a2a3） sum=a2+a3+a2+a3+a1

我们可以发现这个问题和最优矩阵链乘是一个性质 都是要用分治法，把石子分成两堆，每堆石子的和尽可能小

代码超时，上题代码复杂度是n^3, 四边形不等式优化，时间复杂度降到n^2

核心思路是：1、满足四边形不等式优化的条件 2、dp[i][j]的最优分割点p[i][j]具有单调性

#include<cstdio>
#include<cstring>
using namespace std;
const int N=1e3+10;
const int INF=0x3f3f3f3f;
int sum[N];         //记录前i个石子堆总重，前缀和计算区间重量
int dp[N][N];       //记录合并第i个到第j个石子堆需要的最小花费
int p[N][N];
int main()
{
    int n;
    scanf("%d",&n);
    sum[0]=0;
    for(int i=1;i<=n;++i)
    {
        scanf("%d",&sum[i]);
        sum[i]+=sum[i-1];
    }

    for(int i=1;i<=n;++i)
    {
         dp[i][i]=0;
         p[i][i]=i;
    }
     for(int l=2;l<=n;++l)       //枚举石头堆范围
    {
        for(int i=1;i+l-1<=n;++i)   //枚举石头堆起始位置
        {
            int j=i+l-1;            //最后一个石头堆
            dp[i][j]=INF;
            for(int k=p[i][j-1];k<=p[i+1][j];++k)       //由于是按照区间长度来更新的，所以p[i+1][j]比p[i][j]早更新到
            {
                int tmp=dp[i][k]+dp[k+1][j];
                if(dp[i][j]>tmp)
                {
                    dp[i][j]=tmp;
                    p[i][j]=k;      //p[i][j]记录的是合并第i堆到第j堆的最优分割点
                }

            }
            dp[i][j]+=sum[j]-sum[i-1];
        }
    }


    printf("%d\n",dp[1][n]);
    return 0;
}