用动态规划算法设计实现矩阵连乘问题、最长公共子序列问题，C语言，给出源代码

动态规划是一种通过把原问题分解成相互重叠的子问题，并保存子问题的解来求解复杂问题的算法。对于矩阵连乘问题和最长公共子序列问题，我们可以分别用动态规划来优化。

1. **矩阵连乘** (Matrix Chain Multiplication - MCP)
动态规划可以用于计算两个矩阵A、B和C之间最短的乘法路径，使得总的乘法次数最少。源代码示例（C语言）：

   #include <stdio.h>
   int minMult(int arr[], int n);
   
   int main() {
       int arr[] = {4, 5, 2, 6, 3, 7};
       int n = sizeof(arr) / sizeof(arr[0]);
       printf("Minimum number of multiplications required is %d\n", minMult(arr, n));
       return 0;
   }
   
   // 动态规划函数
   int minMult(int arr[], int n) {
       int dp[n][n];
       
       for (int l=2; l<n; l++) {
           for (int i=0; i<n-l; i++) {
               int j = i + l;
               dp[i][j] = INT_MAX;
               for (int k=i; k<j; k++) {
                   dp[i][j] = min(dp[i][j], arr[i]*arr[k+1]+arr[k+1]*arr[j] + dp[i][k] + dp[k+1][j]);
               }
           }
       }
       return dp[0][n- LCS)
   对于两个字符串X和Y，动态规划可以帮助找到它们的最长公共子序列。源代码示例：

#include <stdio.h>
#include <string.h>

int lcs(char* X, char* Y, int m, int n);

int main() {
char X[] = "ABCBDAB";
char Y[] = "BDCAB";
int m = strlen(X);
int n = strlen(Y);
printf("Length of LCS is %d\n", lcs(X, Y, m, n));
return 0;
}

// 动态规划函数
int lcs(char* X, char* Y, int m, int n) {
int L[m + 1][n + 1];

for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n; j++) {
if (i == 0 || j == 0) {
L[i][j] = 0;
} else if (X[i - 1] == Y[j - 1]) {
L[i][j] = L[i - 1][j - 1] + 1;
} else {
L[i][j] = max(L[i - 1][j], L[i][j - 1]);
}
}
}
return L[m][n];
}