C语言代码用递归算法实现矩阵链：输入:矩阵链Ai…j的输入为向量P=<Pi-1,Pi,…,Pj>，其中:1<=i<=j<=n. 输出:计算Ai…j的所需最小乘法运算次数m[i,j]和最后一次运算位置s[i,j]。

在C语言中，矩阵链乘法通常通过递归算法来解决。这是一个经典的动态规划问题，用于优化计算一系列矩阵相乘的操作序列。以下是递归函数的基本思路：

#include <stdio.h>

// 定义一个结构体表示矩阵和其在链表中的索引
typedef struct {
    int start, end; // 矩阵的起始和结束索引
    int m; // 当前矩阵的尺寸
} Matrix;

// 递归函数，计算最小乘法次数和最后操作位置
int matrixChainOrder(int P[], int n) {
    if (n <= 1)
        return 0, 0; // 如果只有一个元素，直接返回

    int dp[n][n]; // 动态规划数组，dp[i][j]表示最优乘积路径
    int minOps[n][n], lastOp[n][n];

    for (int l = 1; l < n; ++l) {
        for (int i = 1; i + l - 1 < n; ++i) {
            int j = i + l - 1;
            dp[i][j] = INT_MAX; // 初始化为最大值，避免无限循环
            int tempCost = 0; // 临时成本

            // 遍历所有可能的分割点k
            for (int k = i; k < j; ++k) {
                tempCost = dp[i][k] + dp[k + 1][j] +
                          (P[i - 1] * P[k] + P[k] * P[j]) * matrixSize(P, i, j);
                if (tempCost < dp[i][j]) {
                    dp[i][j] = tempCost;
                    lastOp[i][j] = k; // 更新最后操作位置
                }
            }
            minOps[i][j] = dp[i][j];
        }
    }

    return dp[1][n - 1], lastOp[1][n - 1];
}

// 计算矩阵的维度
int matrixSize(Matrix* matrices, int i, int j) {
    return matrices[i - 1].end - matrices[i - 1].start + 1;
}

int main() {
    int P[] = {4, 5, 2, 3}; // 示例输入
    int n = sizeof(P) / sizeof(P[0]);
    int minOps, lastOp;
    minOps, lastOp = matrixChainOrder(P, n);

    printf("Minimum number of operations: %d\n", minOps);
    printf("Last operation position: %d\n", lastOp);
    return 0;
}

在这个例子中，`matrixChainOrder` 函数负责递归计算并返回最小乘法次数和最后操作位置。注意，实际应用中需要处理输入矩阵链的边界条件，并将输入矩阵信息存储在一个`Matrix`结构中。