c++输入两个字符串输出最大值

在 C++ 中，如果你想比较两个字符串并输出最长的那个，你可以通过比较它们的长度来进行。下面是一个简单的示例程序：

#include <iostream>
#include <string>

std::string getLongestString(const std::string& str1, const std::string& str2) {
    if (str1.length() > str2.length()) {
        return str1;
    } else {
        return str2;
    }
}

int main() {
    std::string str1, str2;
    std::cout << "请输入第一个字符串: ";
    std::getline(std::cin, str1);
    std::cout << "请输入第二个字符串: ";
    std::getline(std::cin, str2);

    std::string longest = getLongestString(str1, str2);
    std::cout << "最长的字符串是: " << longest << std::endl;

    return 0;
}

在这个程序中，`getLongestString` 函数接受两个字符串作为参数，并返回较长的一个。`main`函数中从用户那里获取两个字符串，然后调用 `getLongestString` 并输出结果。

相关问题

给一个字符串 最多 改变 1 个字符，求字符串的回文子串个数的最大值； 输入 一个字符串 输出 一个整数 完整的c++代码

要解决这个问题，我们可以使用动态规划的方法。首先，我们需要遍历字符串，对于每个位置i，计算以i为起点的最长回文子串长度。然后，我们考虑两种情况：如果当前位置不是中心，我们可以尝试将它替换为它的对称字符（如果存在）来构造更长的回文；如果是中心，那么该字符不能改变，但我们仍然可以从i+1开始寻找可能的回文。

下面是C++代码实现：

#include <iostream>
#include <string>

int longestPalindrome(std::string s) {
    int n = s.length();
    int dp[n][n]; // dp[i][j]表示s[i..j]是否为回文
    int maxLen = 0; // 长度最大的回文子串

    for (int i = 0; i < n; ++i) {
        dp[i][i] = true;
        maxLen = 1;
    }

    for (int len = 2; len <= n; ++len) {
        for (int i = 0; i + len - 1 < n; ++i) {
            int j = i + len - 1;

            if (len == 2 && s[i] != s[j]) {
                dp[i][j] = false;
            } else if (s[i] == s[j]) {
                dp[i][j] = dp[i + 1][j - 1];
            } else {
                dp[i][j] = false;
                if (s[i] == s[j - 1]) { // 尝试将i的字符替换为j-1的字符
                    dp[i][j] = dp[i + 1][j - 2];
                }
            }

            maxLen = std::max(maxLen, dp[i][j]);
        }
    }

    return maxLen;
}

int main() {
    std::string input;
    std::cout << "Enter a string: ";
    std::cin >> input;

    int result = longestPalindrome(input);
    std::cout << "The maximum number of palindromic substrings with at most one change is: " << result << std::endl;

    return 0;
}

运行这段代码后，请输入你要检查的字符串，程序将返回最多改变一个字符时，字符串能构成的回文子串的最大数量。

C++实现输入两个字符串，找两个字符串公共子串

在C++中，我们可以使用动态规划的方法来找到两个字符串之间的最长公共子串。这里是一个简单的实现步骤：

#include <iostream>
#include <string>
#include <vector>

std::string longestCommonSubstring(const std::string& s1, const std::string& s2) {
    int m = s1.length();
    int n = s2.length();

    // 创建一个二维数组来存储中间结果
    std::vector<std::vector<int>> dp(m + 1, std::vector<int>(n + 1, 0));

    int maxLength = 0;
    int endPos = -1;

    // 遍历s1和s2
    for (int i = 1; i <= m; ++i) {
        for (int j = 1; j <= n; ++j) {
            if (s1[i - 1] == s2[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1] + 1; // 如果字符匹配，长度加一
                if (dp[i][j] > maxLength) { // 更新最长公共子串的信息
                    maxLength = dp[i][j];
                    endPos = i - 1; // 当前结束位置
                }
            }
        }
    }

    // 根据endPos回溯构建最长公共子串
    std::string result(endPos - maxLength + 1, ' ');
    s1.copy(result.begin(), endPos + 1, endPos + 1 - maxLength);
    return result;
}

int main() {
    std::string str1 = "hello";
    std::string str2 = "worldhello";
    std::cout << "Longest common substring is: " << longestCommonSubstring(str1, str2) << std::endl;
    return 0;
}

在这个程序中，我们首先初始化一个动态规划矩阵`dp`，然后通过双层循环比较两个字符串的每个字符。如果字符相同，就将上一行和上一列的值加一，并检查是否更新了当前找到的最大公共子串的长度。最后，返回最长公共子串。