帮我写一个c语言代码，解决矩阵连乘问题。要求，输入：多个矩阵的结构向量，输出：最小代价的一个乘法顺序。

在C语言中，解决矩阵连乘问题通常涉及到动态规划的思想，用于寻找最优的矩阵乘法路径以最小化所需的计算步骤。这里是一个简单的示例，我们将编写一个函数`find_min_cost_order`来解决这个问题。首先，我们需要一个数据结构来表示矩阵，并定义一个辅助函数`cost`计算两个矩阵相乘的成本。

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int rows;
    int cols;
} Matrix;

int cost(const Matrix *A, const Matrix *B) {
    return A->rows == B->cols ? B->rows : -1; // 如果无法直接相乘，则成本设为-1
}

Matrix *read_matrix(int size) {
    Matrix *matrix = (Matrix*)malloc(sizeof(Matrix));
    matrix->rows = size;
    scanf("%d", &matrix->cols);
    return matrix;
}

// 动态规划函数，找到最小成本的矩阵乘法顺序
Matrix* find_min_cost_order(int n, Matrix** matrices) {
    int dp[n][n]; // 初始化二维数组
    for (int i = 0; i < n; i++) {
        dp[i][i] = 0; // 单个矩阵的成本为0
    }

    for (int l = 2; l <= n; l++) { // 从2到n，l表示需要连接的矩阵数
        for (int i = 0; i < n - l + 1; i++) { // 遍历所有可能的起始位置
            int j = i + l - 1;
            for (int k = i; k < j; k++) { // 遍历中间矩阵
                dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j] + cost(matrices[i], matrices[k+1])); // 更新dp值
            }
        }
    }

    // 找到最终最小成本的顺序
    int min_cost_index = dp[0][n-1];
    Matrix *result = matrices[min_cost_index];
    printf("Minimum cost order: %d\n", min_cost_index);

    // 回溯得到最优顺序
    for (int i = n - 1, prev_index = min_cost_index; i >= 0; i--) {
        if (dp[prev_index][i] != -1) { // 只有能接续的部分才有意义
            result = matrices[i];
            printf("%d ", i);
            prev_index = i;
        }
    }
    printf("\n");
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    Matrix **matrices = malloc(n * sizeof(Matrix*));
    for (int i = 0; i < n; i++) {
        matrices[i] = read_matrix(n); // 读取矩阵并存储在数组中
    }
    Matrix* final_order = find_min_cost_order(n, matrices);
    free(matrices);
    return 0;
}

这个程序首先读入矩阵的数量和每个矩阵的维度，然后通过动态规划计算出最小成本的矩阵乘法顺序。最后回溯打印出整个最优序列。