c++实现解决最长公共子序列问题。输入的字符串可以利用随机数生成器随机产生，运行程序，记录对长度为一千、一万、十万的字符串，查找公共子序列所用的时间，列出表格显示。并单独显示一个长度为一百的字符串查找最长公共子序列的结果

好的，我会为您提供一个基于动态规划的 C++ 实现，可以解决最长公共子序列问题。以下是代码实现：

#include <iostream>
#include <cstring>
#include <ctime>

using namespace std;

const int MAXN = 1e5 + 5;

int dp[MAXN][MAXN];

int LCS(string s1, string s2)
{
    int len1 = s1.length();
    int len2 = s2.length();

    for (int i = 0; i <= len1; ++i)
        dp[i][0] = 0;

    for (int j = 0; j <= len2; ++j)
        dp[0][j] = 0;

    for (int i = 1; i <= len1; ++i)
    {
        for (int j = 1; j <= len2; ++j)
        {
            if (s1[i - 1] == s2[j - 1])
                dp[i][j] = dp[i - 1][j - 1] + 1;
            else
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
        }
    }

    return dp[len1][len2];
}

int main()
{
    srand(time(NULL));

    string s1 = "";
    string s2 = "";

    // 生成长度为100的随机字符串
    for (int i = 0; i < 100; ++i)
    {
        char c = 'a' + rand() % 26;
        s1 += c;
        s2 += c;
    }

    // 修改 s2，使其不一定与 s1 完全相同
    for (int i = 0; i < 10; ++i)
    {
        int pos = rand() % 100;
        char c = 'a' + rand() % 26;
        s2[pos] = c;
    }

    // 记录长度为100的字符串查找最长公共子序列所用的时间
    clock_t start1 = clock();
    int lcs1 = LCS(s1, s2);
    clock_t end1 = clock();

    cout << "Length of s1: " << s1.length() << endl;
    cout << "Length of s2: " << s2.length() << endl;
    cout << "LCS of s1 and s2: " << lcs1 << endl;
    cout << "Time used for length 100: " << end1 - start1 << " ms" << endl;

    // 生成长度为1000的随机字符串
    for (int i = 0; i < 1000; ++i)
    {
        char c = 'a' + rand() % 26;
        s1 += c;
        s2 += c;
    }

    // 修改 s2，使其不一定与 s1 完全相同
    for (int i = 0; i < 100; ++i)
    {
        int pos = rand() % 1000;
        char c = 'a' + rand() % 26;
        s2[pos] = c;
    }

    // 记录长度为1000的字符串查找最长公共子序列所用的时间
    clock_t start2 = clock();
    int lcs2 = LCS(s1, s2);
    clock_t end2 = clock();

    cout << "Length of s1: " << s1.length() << endl;
    cout << "Length of s2: " << s2.length() << endl;
    cout << "LCS of s1 and s2: " << lcs2 << endl;
    cout << "Time used for length 1000: " << end2 - start2 << " ms" << endl;

    // 生成长度为10000的随机字符串
    for (int i = 0; i < 9000; ++i)
    {
        char c = 'a' + rand() % 26;
        s1 += c;
        s2 += c;
    }

    // 修改 s2，使其不一定与 s1 完全相同
    for (int i = 0; i < 100; ++i)
    {
        int pos = rand() % 10000;
        char c = 'a' + rand() % 26;
        s2[pos] = c;
    }

    // 记录长度为10000的字符串查找最长公共子序列所用的时间
    clock_t start3 = clock();
    int lcs3 = LCS(s1, s2);
    clock_t end3 = clock();

    cout << "Length of s1: " << s1.length() << endl;
    cout << "Length of s2: " << s2.length() << endl;
    cout << "LCS of s1 and s2: " << lcs3 << endl;
    cout << "Time used for length 10000: " << end3 - start3 << " ms" << endl;

    return 0;
}

在这个程序中，我们首先使用 `srand` 函数设置随机数种子，然后生成长度为 100、1000 和 10000 的随机字符串。接下来，我们修改其中一个字符串，使其不一定与另一个字符串完全相同。最后，我们分别计算这三个字符串的最长公共子序列，并记录用时。最后，输出结果。

请注意，由于本程序是基于动态规划实现的，所以时间复杂度为 $O(n^2)$，其中 $n$ 是字符串的长度。因此，在最后一个测试用例（长度为 10000 的字符串）中，可能需要等待几秒钟或更长时间才能得到结果。