精华内容
下载资源
问答
  • JAVA算法:回文字符串相关问题详解(回文字符串总结)
    千次阅读
    2019-06-27 21:52:55

    JAVA算法:回文字符串相关问题详解(回文字符串总结)

    Q1. 编写一个工具方法判断给定的字符串是否为回文字符串

     例如:给定一个字符串“aabbaa”,判断该字符串是否为回文字符串。

    算法设计如下:

    	/*
    	 * 给定一个字符串,判断该字符串是否为一个回文字符串
    	 * start表示需要判断的起始位置
    	 * end表示需要判断的结束位置
    	 */
    
    	public static boolean isPalindrome(String input, int start, int end) {
    		while (start < end) {
    			if (input.charAt(start++) != input.charAt(end--))
    				return false;
    		}
    		return true;
    	}

    完整的测试代码如下:

    package com.bean.algorithm.palindromic;
    
    public class PalindromicUtils {
    
    	/*
    	 * 给定一个字符串,判断该字符串是否为一个回文字符串
    	 * start表示需要判断的起始位置
    	 * end表示需要判断的结束位置
    	 */
    
    	public static boolean isPalindrome(String input, int start, int end) {
    		while (start < end) {
    			if (input.charAt(start++) != input.charAt(end--))
    				return false;
    		}
    		return true;
    	}
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		String str="aabbaa ";
    		//String str="fafadabcbafdfdfas";
    		//注意去掉字符串前后的空格
    		str=str.trim();
    		boolean flag=isPalindrome(str,0,str.length()-1);
    		System.out.println("Flag is: "+flag);
    		
    	}
    
    }
    

    程序运行结果;

    Flag is: true


    Q2. 求给定字符串中的最长回文子串

    输入一个字符串,求出其中最长的回文子串。

    子串的含义是:在原串中连续出现的字符串片段。

    在求解这个问题的时候,一定要看清楚问题。不要混淆“子串”和“子序列”的概念。“子串”是指在源字符串中连续出现的字符串片段;而“子序列”是指在源字符串中可以不连续出现的字符串片段。一个连续,一个不连续。


    回文的含义是:子串从左向右看和从右向左看是相同的,例如:abba,yyxyy。 在判断时忽略所有标点符号和空格,且忽略大小写,但是输出应保持原样。
    输入字符串的长度不超过5000,且占据单独一行。 应该输出最长的回文串。如果有多个,输出起始位置最靠左的一个。

    例如给定字符串:fafadabcbafdfdfas

    其最长回文子串为:afdfdfa

    算法设计如下:

    package com.bean.algorithmexec;
    
    import java.io.FileNotFoundException;
    
    public class LongestPalindromeString3 {
    
    	/*
    	 *  
    	 * 输入一个字符串,求出其中最长的回文子串。 
    	 * 子串的含义是:在原串中连续出现的字符串片段。
    	 * 回文的含义是:子串从左向右看和从右向左看是相同的,例如:abba,yyxyy。 在判断时忽略所有标点符号和空格,且忽略大小写,但是输出应保持原样。
    	 * 输入字符串的长度不超过5000,且占据单独一行。 应该输出最长的回文串。如果有多个,输出起始位置最靠左的一个。
    	 *  
    	 */
    
    	/*
    	 * 动态规划算法
    	 * dp(i, j) 表示是否 s(i ... j) 能够形成一个回文字符串
    	 * 当 s(i) 等于 s(j) 并且  s(i+1 ... j-1) 是一个回文字符串时 dp(i, j) 的取值为 true
    	 * 当我们找到一个回文子字符串时,我们检查其是否为最长的回文字符串
    	 */
    	public static String longestPalindrome(String s) {
    		// n表示字符串的长度
    		int n = s.length();
    		String res = null;
    		// 定义一个dp数组
    		boolean[][] dp = new boolean[n][n];
    		// 外层循环控制从最后一个字符向第一个字符渐进
    		for (int i = n - 1; i >= 0; i--) {
    			// 内层循环控制
    			for (int j = i; j < n; j++) {
    				// dp数组元素
    				dp[i][j] = s.charAt(i) == s.charAt(j) && (j - i < 3 || dp[i + 1][j - 1]);
    
    				if (dp[i][j] && (res == null || j - i + 1 > res.length())) {
    					res = s.substring(i, j + 1);
    				}
    			}
    		}
    
    		return res;
    	}
    
    	public static void main(String[] args) throws FileNotFoundException {
    			// 读取输入的字符串
    			String strdemo = "fafadabcbafdfdfas";
    			String ANSWER = longestPalindrome(strdemo);
    			System.out.println(ANSWER);
    	}
    }
    

    程序运行结果:

    afdfdfa

    另外一种算法:

    package com.bean.algorithmexec;
    
    public class LongestPalindromeString4 {
    
    	static void printSubStr(String str, int low, int high) {
    		System.out.println(str.substring(low, high + 1));
    	}
    
    
    	static int longestPalSubstr(String str) {
    		int maxLength = 1; 
    
    		int start = 0;
    		int len = str.length();
    
    		int low, high;
    
    	
    		for (int i = 1; i < len; ++i) {
    			
    			low = i - 1;
    			high = i;
    			while (low >= 0 && high < len && str.charAt(low) == str.charAt(high)) {
    				if (high - low + 1 > maxLength) {
    					start = low;
    					maxLength = high - low + 1;
    				}
    				--low;
    				++high;
    			}
    
    		
    			low = i - 1;
    			high = i + 1;
    			while (low >= 0 && high < len && str.charAt(low) == str.charAt(high)) {
    				if (high - low + 1 > maxLength) {
    					start = low;
    					maxLength = high - low + 1;
    				}
    				--low;
    				++high;
    			}
    		}
    
    		System.out.print("最长回文子串为: ");
    		printSubStr(str, start, start + maxLength - 1);
    
    		return maxLength;
    	}
    
    	
    	public static void main(String[] args) {
    		String str = "fafadabcbafdfdfas";
    
    		System.out.println("长度是: " + longestPalSubstr(str));
    
    	}
    }
    

    程序运行结果为:

    最长回文子串为: afdfdfa
    长度是: 7


    Q3. 对于给定的字符串输出所有可能的回文子串分区

    例如:给定字符串 str = “bcc”

    输出结果为:["b", "c", "c"], ["b", "cc"]

    算法设计:

    package com.bean.algorithm.palindromic;
    
    import java.util.ArrayList;
    import java.util.Deque;
    import java.util.LinkedList;
    
    public class PrintAllPalindrome {
    
    	public static void main(String[] args) {
    		String input = "abbcbba";
    		//String input = "fafadabcbafdfdfas ";
    		
    		System.out.println("对于给定的字符串 " + input + " 的所有可能的回文分区 :");
    
    		allPalPartitions(input);
    	}
    
    	private static void allPalPartitions(String input) {
    		int n = input.length();
    
    		// 用于存放所有回文子串( palindromic partitions)
    		ArrayList<ArrayList<String>> allPart = new ArrayList<>();
    
    		// 用于存放当前回文子串( palindromic partitions)
    		Deque<String> currPart = new LinkedList<String>();
    
    		// 递归调用方法生成所有分区部分
    		allPalPartitonsUtil(allPart, currPart, 0, n, input);
    
    		// 输出所有分区部分字符串
    		for (int i = 0; i < allPart.size(); i++) {
    			for (int j = 0; j < allPart.get(i).size(); j++) {
    				System.out.print(allPart.get(i).get(j) + " ");
    			}
    			System.out.println();
    		}
    
    	}
    
    
    	private static void allPalPartitonsUtil(ArrayList<ArrayList<String>> allPart, Deque<String> currPart, int start,
    			int n, String input) {
    		
    		if (start >= n) {
    			allPart.add(new ArrayList<>(currPart));
    			return;
    		}
    
    		for (int i = start; i < n; i++) {
    
    			// 如果子串  str[start..i] 是回文子串( palindrome)
    			if (isPalindrome(input, start, i)) {
    
    				currPart.addLast(input.substring(start, i + 1));
    
    				allPalPartitonsUtil(allPart, currPart, i + 1, n, input);
    
    				// 从当前分区中删除子串 str[start..i]
    				currPart.removeLast();
    			}
    		}
    	}
    
    	// 判断字符串是否为回文字符串(Palindrome)的工具方法(utility function) 
    	private static boolean isPalindrome(String input, int start, int i) {
    		while (start < i) {
    			if (input.charAt(start++) != input.charAt(i--))
    				return false;
    		}
    		return true;
    	}
    
    }
    

    程序运行结果:

    对于给定的字符串 abbcbba 的所有可能的回文分区 :
    a b b c b b a 
    a b b c bb a 
    a b bcb b a 
    a bb c b b a 
    a bb c bb a 
    a bbcbb a 
    abbcbba 

     

    更多相关内容
  • 判断一个是否是回文字符串回文字符串是指正序(从左向右)和倒序(从右向左)读都是一样的字符串。 示例1 输入:abc 输出:false 示例2 输入:-121 输出:false 示例3 输入:abba 输出:true 判断是否为回文...
  • 回文字符串

    2019-01-28 20:17:58
    资源--回文字符串
  • 回文 利用python 自带的翻转 函数 reversed() def is_plalindrome(string): return string == ''.join(list(reversed(string)))` 自己实现 def is_plalindrome(string): string = list(string) length = len...
  • Python实现最短回文字符串输出
  • 大连学软件学院 DaLian University of Technology School of Software 数据结构与算法 Fo软件学院08级本科生20092010秋 3字符串 学软件学院 Dalian University of Te School of software 要容 字符串抽象数据类型 ...
  • 代码实现输入任意字符串,并计算输入字符串最大回文长度,并返回回文字符串
  • 本文实例讲述了Python回文字符串及回文数字判定功能。分享给大家供大家参考,具体如下: 所谓回文字符串,就是一个字符串,从左到右读和从右到左读是完全一样的。回文数字也是如此。 python2代码如下: def huiwen...
  • 680. 验证回文字符串 Ⅱ 给定一个非空字符串 s,最多删除一个字符。判断是否能成为回文字符串。 示例 1: 输入: “aba” 输出: True 示例 2: 输入: “abca” 输出: True 解释: 你可以删除c字符。 注意: 字符串只包含...
  • C语言判断回文字符串代码
  • LeetCode刷题笔记 字符串 回文字符串

    千次阅读 2021-11-01 13:14:24
    给定一个字符串,验证它是否是回文串,只考虑字母和数字字符,可以忽略字母的大小写。 输入一个字符串,输出一个布尔值表示该字符串是否为回文串 输入: “A man, a plan, a canal: Panama” 输出: true 解释:...

    125 验证回文串

    给定一个字符串,验证它是否是回文串,只考虑字母和数字字符,可以忽略字母的大小写。

    输入一个字符串,输出一个布尔值表示该字符串是否为回文串

    输入: “A man, a plan, a canal: Panama”
    输出: true
    解释:“amanaplanacanalpanama” 是回文串

    解析:

    回文串一般都可以采用双指针从两头向中间检验,或者采用中心扩展法从中间向两头验证是否为回文串。

    ​ 本题可以采用双指针的策略,从字符串首尾两端逐个字符检验。但是本题中给出的字符串有许多非字母字符,可以用一个新字符串保存原字符串中的所有字母小写形式,然后对其使用双指针方法验证。

    class Solution {
    public:
        bool isPalindrome(string s) {
            // 筛选出字母内容
            string sgood;
            for (char ch: s) {
                if (isalnum(ch)) {
                    sgood += tolower(ch);
                }
            }
            // 双指针验证回文串
            int n = sgood.size();
            int left = 0, right = n - 1;
            while (left < right) {
               if (sgood[left] != sgood[right]) {
                    return false;
                }
                ++left;
                --right;
            }
            return true;
        }
    };
    

    680 验证回文字符串 Ⅱ

    给定一个非空字符串 s最多删除一个字符。判断是否能成为回文字符串。

    输入一个字符串,输出一个布尔值表示该字符串是否能通过删除操作构成回文串

    输入: s = “abca”
    输出: true
    解释: 你可以删除c字符。

    解析:

    ​ 本题采用双指针的方法检验回文串,两个指针分别指向字符串的头和尾,逐一比较两个指针指向的元素。当出现两个指针指向的字符不想等的情况时分别检验将头指针指向的元素删除和将尾指针指向的元素删除两种情况下继续比较字符,是否仍然可以构成回文串。

    class Solution {
    public:
        bool subPalindrome(string s, int head, int tail){
            for(;head<tail;++head,--tail){
                if(s[head]!=s[tail]){
                    return false;
                }
            }
            return true;
        }
    
        bool validPalindrome(string s) {
            int head = 0, tail = s.size()-1;
            while(head<tail){
                if(s[head]==s[tail]){
                    ++head;
                    --tail;
                }else{
                    if( subPalindrome(s,head,tail-1)||subPalindrome(s,head+1,tail)){
                        return true;
                    }else{
                        return false;
                    }
                }
            }
            return true;
        }
    };
    

    647 回文子串

    给定一个字符串,求其有多少个回文子字符串。回文的定义是左右对称。

    输入是一个字符串,输出一个整数,表示回文子字符串的数量。

    输入:s = “aaa”
    输出:6
    解释:6个回文子串: “a”, “a”, “a”, “aa”, “aa”, “aaa”

    解析:

    ​ 本题采用中心扩展法,可以从字符串的每个位置开始,向左向右延长,判断存在多少以当前位置为中轴的回文子字符串。中心扩展法:枚举每一个可能的回文中心,然后用两个指针分别向左右两边拓展,当两个指针指向的元素相同的时候就拓展,否则停止拓展。枚举过程中要区分子串的长度为偶数情况和奇数情况。

    class Solution {
    public:
        int countCurSub(string s, int lsh, int rsh){
            int count = 0;
            while(lsh>=0 && rsh<s.length() && s[lsh]==s[rsh]){
                --lsh;
                ++rsh;
                ++count;
            }
            return count;
        }
    
        int countSubstrings(string s) {
            int ans = 0;
            for(int i=0;i<s.length();++i){
                // 长度为奇数的回文子串
                ans += countCurSub(s,i,i);
                // 长度为偶数的回文子串
                ans += countCurSub(s,i,i+1);
            }
            return ans;
        }
    };
    

    409 最长回文串

    给定一个包含大写字母和小写字母的字符串,找到通过这些字母构造成的最长的回文串。

    输入一个字符串,输出一个整数表示可组成的最长回文串长度

    输入: “abccccdd”
    输出: 7
    解释: 可以构造的最长的回文串是"dccaccd", 它的长度是 7

    解析:

    ​ 本题采用哈希表辅助统计给出字符串中每个字符频次,频次为偶数的可以全部加入构成回文串,频次为奇数的减去一个剩下的也可以加入构成回文串。需要注意的是如果有奇数频次的字符,那么构成的回文串总长可以为奇数,该字符可以出现在回文串中心。

    class Solution {
    public:
        int longestPalindrome(string s) {
            unordered_map<char,int> chCnt;
            for(const auto ch: s){
                ++chCnt[ch];
            }
            bool hasOdd = false;
            int ans = 0;
            for(const auto [key,cnt]: chCnt){
                if(cnt&1){
                    ans+=(cnt-1);
                    hasOdd = true;
                }else{
                    ans+=cnt;
                }
            }
            return hasOdd?ans+1:ans;
        }
    };
    

    5 最长回文子串

    给定一个字符串 s,找到 s 中最长的回文子串。

    输入一个字符串,输出一个字符串表示最长回文子串

    输入:s = “babad”
    输出:“bab”
    解释:“aba” 同样是符合题意的答案

    解析:

    ​ 本题和647 回文子串相似,可以采用中心扩展法寻找最长回文子串。分别考虑子串长度为奇数和偶数的情况,奇数的中心只有一个,偶数长度的中心为 i 和 i+1;以此中心使用两个指针分别向左向右扩展,逐一比较两个指针指向元素的值是否相等;出现不等情况时,使用一个pair对象返回已经检验的回文子串的起始位置和结束位置。

    ​ 遍历所有回文子串,比较子串的长度,不断更新较长回文子串的起始和结束位置,最终使用substr()方法切片获得最长回文子串。

    class Solution {
    public:
        pair<int,int> subStr(string s, int lsh, int rsh){
            while(lsh>=0 && rsh<s.length() &&s[lsh]==s[rsh]){
                --lsh;
                ++rsh;
            }
            return {lsh+1,rsh-1};
        }
    
        string longestPalindrome(string s) {
            int start = 0, end=0;
            for(int i=0; i<s.length();++i){
                pair<int,int> oddStr = subStr(s,i,i);
                pair<int,int> evenStr = subStr(s,i,i+1);
                if(oddStr.second-oddStr.first > end-start){
                    start = oddStr.first;
                    end = oddStr.second;
                }
                if(evenStr.second-evenStr.first > end-start){
                    start = evenStr.first;
                    end = evenStr.second;
                }
            }
            return s.substr(start,end-start+1);
        }
    };
    

    参考资料

    LeetCode 101:和你一起轻松刷题(C++) 第 12 章 令人头大的字符串

    展开全文
  • 由题意可知:回文字符串指该字符串正序与其逆序逐字符一致,根据规则,判断字符串是否为“回文字符串”首先想到的是要拿第一个字符与最后一个字符比较,然后第二个字符与倒数第二个字符比较,第三个与倒数第三个字符...

    描述
    给定一个长度为 n 的字符串,请编写一个函数判断该字符串是否回文。如果是回文请返回true,否则返回false。
    字符串回文指该字符串正序与其逆序逐字符一致。
    数据范围:0 < n≤1000000

    解题思路:

    由题意可知:回文字符串指该字符串正序与其逆序逐字符一致,根据规则,判断字符串是否为“回文字符串”首先想到的是要拿第一个字符与最后一个字符比较,然后第二个字符与倒数第二个字符比较,第三个与倒数第三个字符比较......依次循环下去。

    	public boolean judge (String str) {
    		boolean result=true;
    	    //因为比一半就已经确定了,没必要再进行下去,因此length/2
            for (int i = 0; i < str.length()/2; i++) {
             	if(!(str.charAt(i) == str.charAt(str.length() - i - 1))){
             		result=false;
            		break;
            	}
            }
    	        return result;
    	    }

    展开全文
  • JavaScript 回文字符串判断 通过页面弹出的输入框输入要进行判断的字符串,点击确定后,如果该字符串是回文字符串,则弹窗提示:该字符串是回文字符串;如果该字符串不是回文字符串,则弹窗提示:该字符串不是回文...

    JavaScript 回文字符串判断

    什么是回文字符串?

          如果一个字符串反转之后和原本的字符串相同,那么这个字符串就叫做回文字符串。比如:level、上海自来水来自海上、20211202 等都是回文字符串。


    一、需求说明

    通过页面弹出的输入框输入要进行判断的字符串,点击确定后,

    • 如果该字符串是回文字符串,则弹窗提示:该字符串是回文字符串;
    • 如果该字符串不是回文字符串,则弹窗提示:该字符串不是回文字符串。

    二、步骤

    1、封装一个函数,用来判断是不是回文字符串

          1-1   使用 split() 方法将用户输入的字符串转换成数组
          1-2   使用 reverse() 将转换成的数组进行反转
          1-3   使用 join() 方法将反转后的数组转换成新的字符串
          1-4   将原始字符串和新字符串进行比较,如果全等,就表示用户输入的字符串是回文字符串,返回 true ;如果不等,就表示用户输入的字符串不是回文字符串,返回 false

    2、使用 window.prompt() 来让用户输入要进行判断的字符串,调用封装之后的函数进行判断

    • 如果判断结果是 true ,输出:该字符串是回文字符串!
    • 如果判断结果是 false ,输出:该字符串不是回文字符串!

    3、设置一个定时器,使用户可以在判断完一个字符串之后,还可以继续判断其它的字符串。


    三、代码

    <!DOCTYPE html>
    <html lang="en">
    
    <head>
        <meta charset="UTF-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Document</title>
    </head>
    
    <body>
        <script>
            var str = window.prompt('请输入要进行判断的字符串');
    
            if (isPalindromeString(str) === true) {
                window.alert(`您输入的字符串为:${str},它是回文字符串!`);
            } else {
                window.alert(`您输入的字符串为:${str},它不是回文字符串!`);
            }
    
            // 设置一个定时器,使用户可以在判断完一个字符串之后,还可以继续判断别的字符串
            setInterval(() => {
                var str = window.prompt('请输入要进行判断的字符串');
                if (isPalindromeString(str) === true) {
                    window.alert(`您输入的字符串为:${str},它是回文字符串!`);
                } else {
                    window.alert(`您输入的字符串为:${str},它不是回文字符串!`);
                }
            }, 1000);
    
            /*
                isPalindromeString 判断回文字符串
                    @param  string  str 需要判断的字符串
                    @return boolean 判断结果 true / false
    
            */
            // 判断回文字符串函数
            function isPalindromeString(str) {
                // 将字符串每一个字符都转化为数组单元
                var arr = str.split('');
                // 将数组进行反转 
                arr.reverse();
                // 将反转的数组拼接为新的字符串,并且每个字符之间没有间隔
                var newStr = arr.join('');
    
                if (str === newStr) {
                    // 如果新的字符串等于原始字符串 
                    // 返回值是true,表示是回文字符串
                    return true;
                } else {
                    // 否则,返回值是false,表示不是回文字符串
                    return false;
                }
            }
        </script>
    </body>
    
    </html>
    

    四、效果演示


    在这里插入图片描述

    展开全文
  • 最长回文字符串

    2020-12-22 02:35:38
    回文字符串一定存在一个中心 这里分情况讨论: 1.这个回文字符串长度是奇数:那么他中心就在某一个字符上 2.这个回文字符串长度是偶数:那么他中心就在俩字符之间 我们遍历两次 第一次只考虑奇数情况,把遍历的字符...
  • 查找回文字符串

    千次阅读 2020-11-11 00:28:22
    编写一个程序,寻找一篇英文文章中最长的回文字符串回文字符串是具有回文特性的字符串:即该字符串从左向右读,与从右向左读都一样。 输入文件不会超过500字符。这个文件可能一行或多行,但是每行都不超过80个...
  • 然后在中间节点在开辟一个指针按反转的方向往回走, 慢指针继续向前, 当慢指针扫描完整个链表, 前后两段字符串反转方向后相等, 可以判断这是回文字符串。否则可以提前判断这个字符串不是回文字符串。 3. 还原字符串 ...
  • 回文字符串:关于中心做对称的字符串 ;例如:abcdeffedcba adcdefedcba //将字符串从前往后,以及从后往前逐个进行比较,如果比较到中间位置,字符都是一样的就是回文字符串 function isPalindromiStr(str) { //...
  • Raptor-回文字符串判断

    2022-01-03 08:51:18
    我们在Raptor中输入字符串,记为 s,在Raptor中,字符串 s 是以字符数组的形式存在,我们可以利用数组对回文字符串进行判断。 比如字符数组 s = "abcdeedcba",这个数组的长度也即末端索引位置可以用自带函数 ...
  • 判断回文字符串

    2022-03-17 21:17:22
    回文就是字符串中心对称,从左向右读和从右向左读的内容是一样的。 输入一个字符串,判断该字符串是否为回文,只考虑数字和字母字符,字母的大小写没有区别。 输入格式: 输入一个字符串。 输出格式: 是回文,一行...
  • 主要介绍了PHP判断一个字符串是否是回文字符串的方法,实例分析了php操作字符串判断回文的技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • 力扣最长回文字符串

    千次阅读 2022-03-17 13:00:10
    给你一个字符串 s,找到 s 中最长的回文子串。 示例 1: 输入:s = “babad” 输出:“bab” 解释:“aba” 同样是符合题意的答案。 示例 2: 输入:s = “cbbd” 输出:“bb” 提示: 1 <= s.length <= 1000 ...
  • P086 回文字符串

    2021-03-18 09:57:05
    请编写函数fun,该函数的功能是:判断字符串是否为回文,若是,则函数返回1,主函数中输出”YES”,否则返回0,主函数中输出”NO”。回文是指顺读和倒读都一样的字符串。例如,字符串LEVEL是回文,而字符串123312就...
  • pta判断回文字符串

    2021-11-30 18:59:00
    pta判断回文字符串 输入一个字符串,判断该字符串是否为回文。回文就是字符串中心对称,从左向右读和从右向左读的内容是一样的。 输入格式: 输入在一行中给出一个不超过80个字符长度的、以回车结束的非空字符串。 ...
  • Palindrome 回文字符串就是指从前往后和从后往前读,都是一样的,比如“aabcbaa”。注意区分子串和子序列,子串是连续的,子序列可以不连续题型1:判断字符串是否为回文字符串方法:双指针思路:同时从字符串头尾...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 70,150
精华内容 28,060
关键字:

回文字符串