动态规划矩阵连乘c++

动态规划通常用于解决最优化问题，而矩阵连乘（Matrix Chain Multiplication, MCM）是一个经典的问题，可以使用动态规划来求解最小化矩阵相乘的总计算代价。在C++中，我们可以用二维数组dp来存储子问题的最优解。

#include <vector>

std::vector<int> matrixChainOrder(int arr[], int n) {
    std::vector<std::vector<int>> dp(n, std::vector<int>(n));
    
    // 初始化边界条件
    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;
            dp[i][j] = INT_MAX; // 假设初始是最坏情况

            // 遍历所有可能的分解，找到最优路径
            for (int k = i; k < j; k++) {
                dp[i][j] = std::min(dp[i][j], dp[i][k] + dp[k+1][j] + (arr[i-1]*arr[k]*arr[j]));
            }
        }
    }

    // 返回最终的最优顺序
    int result[30]; // 假定矩阵最大大小为30x30
    int index = dp[1][n-1];
    result[index] = 1; // 第一个数总是1
    for (int i = n-2; i >= 1; i--) {
        if (dp[i][index] == dp[i][n-1]) { // 找到相同的值，即连续的子矩阵
            result[index] = i;
            index--;
        } else {
            break;
        }
    }

    return result;
}

// 示例：
int arr[] = {70, 90, 60, 80};
int n = sizeof(arr) / sizeof(arr[0]);
std::vector<int> order = matrixChainOrder(arr, n);

这个函数会返回一个数组`order`，其中包含从左到右矩阵链乘的最优顺序。