沙子划分，矩阵连乘的变形

沙子划分问题

/**
 * @Author Fizz Pu
 * @Date 2020/10/11 下午18:25
 * @Version 1.0
 * 失之毫厘，缪之千里！
 */


/**
 * 题目描述
 * 设有N堆沙子排成一排，其编号为1，2，3，…，N（N< =300）。每堆沙子有一定的数量，可以用一个整数来描述，现在要将N堆沙子合并成为一堆，
 * 每次只能合并相邻的两堆，合并的代价为这两堆沙子的数量之和，合并后与这两堆沙子相邻的沙子将和新堆相邻， 
 * 合并时由于选择的顺序不同，合并的总代价也不相同，如有4堆沙子分别为1 3 5 2我们可以先合并1、2堆，代价为4，
 * 得到4 5 2又合并1，2堆，代价为9，得到9 2，再合并得到11，总代价为4+9+11=24，如果第二步是先合并2，3堆，则代价为7，
 * 得到4 7，最后一次合并代价为11，总代价为4+7+11=22；问题是：找出一种合理的方法，使总的代价最小。输出最小代价。
 * 输入
 * 第一行一个数N表示沙子的堆数N。 第二行N个数，表示每堆沙子的质量。 a[i]< =1000。
 * 输出
 * 合并的最小代价。
 * 样例输入
4
1 3 5 2
 * 样例输出
 22
 */


// 分析，这道题目和矩阵矩阵连乘问题一样

// 1.cost[n][n]中，cost[i][j] 表示合并i:j堆沙子需要的代价
// 2.初始化矩阵
// 2.1沙子只有一堆，代价为0
// 2.2沙子有两堆，代价为数量之和
// 3 沙子有三堆以上，找出状态转移方程 cost[i][j] =  cost[i][k] + cost[k+1][j] + i到j堆沙子的总和 ;循环找k
// 我的天啊！自己还是不小心!遇到个小错误

#include <iostream>
int getMinCost(int*, int);
void dp(int *, int **);
int max(int, int);

int main(){
    int n;
    std::cin  >> n;
    int* sands = new int[n];
    for(int i = 0; i < n; ++i){
        std::cin >> sands[i];
    }
    std::cout<<getMinCost(sands, n) << std::endl;
    delete[] sands;
}

int min(int a, int b){
    return a < b ? a : b;
}


int getMinCost(int* sands, int len){
    if(len <= 1)return 0;
    int cost[len][len];
    for(int j = 0; j < len; ++j){
        cost[j][j] = 0;
    }
    int sums;//表示沙子的和
    for(int i = 2; i <= len; i++){// 表示有i堆沙子
        for(int row = 1; row < len; ++row){ // row开始，最多len堆沙子，最多填len-row+1行, 各个条件之间不要有依赖关系
            int col = row + i - 1;//i堆沙子，共有i堆，自然可以得到列 
            if(col > len)break;
            sums = 0;
            for(int m = row-1; m <= col-1; ++m){
                sums += sands[m];
                }
            if(i == 2){ // 两堆沙子，直接初始化
                cost[row-1][col-1] = sands[row-1] + sands[col-1]; 
            } else{ // 假定最优划分
                cost[row-1][col-1] = cost[row][col-1] + sums;
                // 开始划分
                for(int k = row; k < col; ++k){ // for(int k = 1; k < col - row + 1; ++k) 必然错误啊
                      int expectedCost = cost[row-1][k-1] + cost[k][col-1] + sums;
                      cost[row-1][col-1] = min(expectedCost, cost[row-1][col-1]); 
                }
            }
        }
    }
    return cost[0][len-1];
}