回文的系列题目

最新推荐文章于 2023-06-11 21:06:55 发布

Doooer

最新推荐文章于 2023-06-11 21:06:55 发布

阅读量520

点赞数

分类专栏： leetcode题目

本文链接：https://blog.csdn.net/YQMind/article/details/85776805

版权

leetcode题目专栏收录该内容

15 篇文章 0 订阅

订阅专栏

本文探讨了一系列关于回文字符串的编程题目，包括判断字符串是否为回文、找到最短的回文长度、构造回文以及找出最长回文子串的方法。通过链接提供了具体题目，并分析了解决方案的时间复杂度，涉及动态规划、中心扩展等算法。

摘要由CSDN通过智能技术生成

一、判断一个字符串是不是回文串
题目链接https://www.nowcoder.com/practice/df00c27320b24278b9c25f6bb1e2f3b8?tpId=69&&tqId=29674&rp=1&ru=/activity/oj&qru=/ta/hust-kaoyan/question-ranking

两个指向，一个从左往右，一个从右往左~

#include <iostream>
using namespace std;

int main(){
    string s;
    while(cin>>s){
        int n = s.length();
        int i=0,j=n-1;
        bool res = true;
        for(;i<n/2;){
            if(s[i]!=s[j]){
                res = false;
                break;
            }else{
                i++;
                j--;
            }           
        }
        if(res) cout<<"Yes!"<<endl;
        else cout<<"No!"<<endl;
    }
    
    return 0;
    
}

二、最短的回文长度
题目链接
https://www.nowcoder.com/questionTerminal/4f10d29c0a25491ca7d351fceafee15a
题目描述：给定一个字符串，在其后面添加0个或者多个字符形成回文，求出最短的回文长度。

#include<iostream>
using namespace std;
bool isOK(string s){  // 判断字符串s是不是回文串
    int n=s.length();
    bool res = true;
    int i=0,j=n-1;
    for(;i<n/2;){
        if(s[i]!=s[j]){
            res = false;
            break;
        }
        else{
            i++;
            j--;
        }
    }
    return res;
}
int main(){
    string s;
    cin>>s;
    int n=s.length();
    int index;
    for(int i=0;i<n;i++){
        if(isOK(s.substr(i))) {
            index = i;
            break;
        }
    }
    int res = n+index;
    cout<<res;
    return 0;
}

同样的题目，返回的不是最小长度，而是需要添加的字符串
https://www.nowcoder.com/practice/cfa3338372964151b19e7716e19987ac?tpId=49&&tqId=29361&rp=1&ru=/activity/oj&qru=/ta/2016test/question-ranking

三、构造回文
题目链接
https://www.nowcoder.com/questionTerminal/28c1dc06bc9b4afd957b01acdf046e69

给定一个字符串s，你可以从中删除一些字符，使得剩下的串是一个回文串。如何删除才能使得回文串最长呢？
输出需要删除的字符个数。

这个题本质考察的是最长公共子序列问题，字符串s和它的逆串的最长公共子序列长度

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int getMaxCommon(string s, string s1){
    int n=s.length();
    vector<vector<int>> f(n+1,vector<int>(n+1,0));
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            if(s[i]==s1[j]) 
                f[i+1][j+1]=f[i][j]+1;
            else 
                f[i+1][j+1]=max(f[i+1][j],f[i][j+1]);
        }
    }
    return f[n][n];
}
int main(){
    string s;
    while(cin>>s){
        int n = s.length();
        string s1 = s;
        reverse(s1.begin(),s1.end());
        cout<<n-getMaxCommon(s,s1)<<endl;       
    }  
    return 0;
}

四、最长回文子串
题目链接
https://www.nowcoder.com/practice/b4525d1d84934cf280439aeecc36f4af?tpId=49&&tqId=29360&rp=1&ru=/activity/oj&qru=/ta/2016test/question-ranking

方法一：
暴力穷举，判断每个子串是不是回文的。其中找到每个子串的时间复杂度 $O(n^2)$ ，判断是否为回文串的复杂度为 $O (n)$ 。整个算法时间复杂度为 $O(n^3)$ 。
，

class Palindrome {
public:
    int getLongestPalindrome(string A, int n) {
        if(n<1) return 0;
        int ans=1;
        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){
                if(isOK(A.substr(i,j-i+1))){
                    ans = max(ans, j-i+1);
                }
            }
        }
        return ans;
    }
private:
    bool isOK(string s){
        int n = s.length();
        int i=0,j=n-1;
        for(;i<n/2;){
            if(s[i]!=s[j]){
                return false;
            }
            i++;
            j--;
        }
        return true;
    }
};

方法二：
中心扩展法。遍历字符串的每个字符，然后左右扩展得到该位置的最长回文串，最后进行比较，得到最终结果。时间复杂度是 $O(n^2)$ 。

class Palindrome {
public:
    int getLongestPalindrome(string A, int n) {
        int ans = 0;
        for(int i=0;i<n;i++){
            ans = max(ans, getMaxCommon(A,n,i));
        }
        return ans;
    }
private:
    int getMaxCommon(string A, int n, int index){
        int left = index-1, right = index+1;
        while(right<n && A[right]==A[index])
            right++;
        while(left>=0 && right<n && A[left]==A[right]){
            left--;
            right++;
        }
        return right-left-1;
        
    }
};

方法三：
动态规划法。f[i][j]=1表示 str[i…j]是回文子串。

class Palindrome {
public:
    int getLongestPalindrome(string A, int n) {
        vector<vector<int>> f(n,vector<int>(n,0));
        int ans = 0;
        for(int i=n-1;i>=0;i--){
            for(int j=i;j<n;j++){
                if(j-i<2) {
                    f[i][j]= (A[i]==A[j]);
                }
                else {
                    f[i][j] = (A[i]==A[j] && f[i+1][j-1]);
                }
                if(f[i][j]){
                    ans = max(ans, j-i+1);
                }
            }
            
        }
        return ans;
    }
};

方法四：