构造一个二维数组，填完就是最长子序列，求出来最长子序列是什么，打印出来，测试验证，使用c语言实现

在 C 语言中，你可以使用动态内存分配来构造一个二维数组来表示一个序列，并通过遍历和比较找到最长的递增子序列。这里是一个简单的示例，我们假设输入是一系列整数，我们将使用动态内存分配并用动态规划的思想来解决问题：

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

// 功能：计算给定数组的最大长度递增子序列
int longestIncreasingSubsequence(int** arr, int m, int n) {
    int dp[n][n], len = 0;
    
    // 初始化每个元素的最长子序列长度为1
    for (int i = 0; i < n; i++) {
        dp[i][i] = 1;
    }
    
    // 遍历矩阵，找出最大子序列
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            if (arr[i][j] > arr[i][dp[i][j - 1].index]) {
                dp[j][len++] = dp[i][j - 1]; // 更新最长子序列
            } else {
                dp[j][len] = dp[j][len - 1]; // 如果当前元素小于等于已存在的子序列，则保持不变
            }
        }
    }

    // 打印最长子序列
    printf("Longest increasing subsequence:\n");
    while(len--) {
        printf("%d ", dp[len].value);
        if (dp[len].index != -1)
            printf("(%d, %d)\n", dp[len].index, dp[len].value);
    }

    return len;
}

// 测试函数
void test() {
    int** arr = (int **)malloc(sizeof(int*) * 3);
    for (int i = 0; i < 3; i++) {
        arr[i] = (int *)malloc(sizeof(int) * 4);
        arr[i][0] = 1;
        arr[i][1] = 2;
        arr[i][2] = 5;
        arr[i][3] = 6;
    }

    int m = 3, n = 4;
    int length = longestIncreasingSubsequence(arr, m, n);

    // 输出结果和释放内存
    printf("\nLength of the longest increasing subsequence: %d\n", length);
    for (int i = 0; i < m; i++)
        free(arr[i]);
    free(arr);
}

int main() {
    test();
    return 0;
}

这个代码首先创建了一个二维数组 `arr`，然后通过 `longestIncreasingSubsequence` 函数查找最长递增子序列。最后，在 `test` 函数里对数组进行填充并运行测试。

注意，由于实际的输入可能不是固定大小，上述代码中的动态内存分配可能会因为数组大小未知而需要调整。如果你有具体的输入数据，可以将其替换到相应的部分。在实际情况中，你需要根据输入的规模动态地分配数组。