回文数判断与最长回文输出

NC141 判断回文

记录:
在这里插入图片描述
在这里插入图片描述
下边这个也行:
在这里插入图片描述

bool judge(char* str ) {
// write code here
// write code here
char *pe=str;
char *pa=str;
int t=0;
while( *pe != ‘\0’)
{
t++;
pe++;
}
pe–;
if(t==1)
return true;
while(pa<pe)
{
if(*pa!=*pe)
return false;
pa++;
pe–;
}
return true;
}

参考链接

NC17 最长回文子串

在这里插入图片描述
在这里插入图片描述
import java.util.*;

public class Solution {
public int getLongestPalindrome(String A, int n) {
// write code here
//边界条件判断
if (n < 2)
return A.length();
//maxLen表示最长回文串的长度
int maxLen = 0;
for (int i = 0; i < n; ) {
//如果剩余子串长度小于目前查找到的最长回文子串的长度,直接终止循环
// (因为即使他是回文子串,也不是最长的,所以直接终止循环,不再判断)
if (n - i <= maxLen / 2)
break;
int left = i;
int right = i;
while (right < n - 1 && A.charAt(right + 1) == A.charAt(right))
++right; //过滤掉重复的

    //下次在判断的时候从重复的下一个字符开始判断
    i = right + 1;
    //然后往两边判断,找出回文子串的长度
    while (right < n - 1 && left > 0 && A.charAt(right + 1) == A.charAt(left - 1)) {
        ++right;
        --left;
    }
    //保留最长的
    if (right - left + 1 > maxLen) {
        maxLen = right - left + 1;
    }
}
//截取回文子串
return maxLen;
}

}

参考链接:
原文写的特别好,几种解法,有讲解

<think>嗯,用户现在想了解如何在Java判断最长回文子串。首先,我得确定用户对这个问题的理解程度。可能用户已经知道回文子串的基本概念,但需要具体的实现方法。用户可能是在准备面试,或者在学习算法,或者是实际开发中遇到了相关问题。 接下来,我需要考虑不同的解决方法。最长回文子串的常见解法有暴力法、动态规划和中心扩展法。暴力法的时间复杂度太高,可能不太实用,但可以作为基础理解。动态规划可以优化时间复杂度,但空间复杂度可能较高。中心扩展法则在时间和空间上都比较高效,适合作为主要解法。 然后,用户可能更关注代码的实现细节和效率。我需要解释每种方法的思路,给出具体的Java代码示例。同时,要注意代码的可读性,比如变量命名和结构,确保用户能理解。 用户可能还会想知道不同方法的时间复杂度,比如暴力法是O(n³),动态规划是O(n²),中心扩展法也是O(n²),但实际中中心扩展法更快,因为常数因子更小。需要强调这一点,帮助用户选择合适的方案。 另外,用户可能对特殊测试用例有疑问,比如字符串长度为1,或者全部字符相同的情况。在代码示例中,应该处理这些边界情况,比如在中心扩展法中,当左右字符相同时继续扩展,确保覆盖所有可能的回文。 还要考虑用户可能的误区,例如在动态规划中如何初始化状态表,或者在中心扩展时如何处理偶数和奇数长度回文。需要详细解释这些细节,避免用户在实际编码时出错。 最后,总结部分应该比较不同方法的优缺点,帮助用户根据实际需求选择最合适的解法。同时,提醒用户注意代码的健壮性,比如处理空字符串或null值的情况,虽然示例中可能省略了这些,但在实际应用中需要考虑。</think>### **Java实现最长回文子串详解** 判断最长回文子串是经典的字符串处理问题。下面通过**暴力法、动态规划、中心扩展法**三种方法解析实现原理,给出优化代码时间复杂度对比。 --- #### **一、问题定义** **回文子串**:正读和反读相同的字符串片段 **目标**:在给定字符串`s`中找出**长度最长**的回文子串 **示例**: - 输入:`"babad"` → 输出:`"bab"`或`"aba"` - 输入:`"cbbd"` → 输出:`"bb"` --- #### **二、暴力法(Brute Force)** ##### **思路** 1. 遍历所有可能的子串(双重循环枚举起止点) 2. 检查每个子串是否为回文 3. 记录最长回文子串 ##### **代码实现** ```java public String longestPalindrome(String s) { if (s == null || s.length() < 1) return ""; int maxLen = 0; String res = ""; for (int i = 0; i < s.length(); i++) { for (int j = i; j < s.length(); j++) { String sub = s.substring(i, j + 1); if (isPalindrome(sub) && sub.length() > maxLen) { maxLen = sub.length(); res = sub; } } } return res; } // 辅助方法:检查回文 private boolean isPalindrome(String s) { int left = 0, right = s.length() - 1; while (left < right) { if (s.charAt(left++) != s.charAt(right--)) { return false; } } return true; } ``` ##### **复杂度分析** - 时间复杂度:$O(n^3)$(两层循环$O(n^2)$ × 回文检查$O(n)$) - 空间复杂度:$O(1)$ **适用场景**:仅适用于极短字符串(长度 ≤ 50) --- #### **三、动态规划(DP)** ##### **核心思路** - 定义状态:`dp[i][j]`表示子串`s[i...j]`是否为回文 - 状态转移方程: - 若`s[i] == s[j]`且`dp[i+1][j-1] == true` → `dp[i][j] = true` - 边界条件:当子串长度为1或2时直接判断 ##### **代码实现** ```java public String longestPalindrome(String s) { int n = s.length(); if (n < 2) return s; boolean[][] dp = new boolean[n][n]; int maxLen = 1, start = 0; // 初始化:所有长度为1的子串都是回文 for (int i = 0; i < n; i++) { dp[i][i] = true; } // 枚举子串长度 for (int len = 2; len <= n; len++) { for (int i = 0; i <= n - len; i++) { int j = i + len - 1; // 子串结束位置 if (s.charAt(i) != s.charAt(j)) { dp[i][j] = false; } else { if (len == 2) { dp[i][j] = true; } else { dp[i][j] = dp[i + 1][j - 1]; } } // 更新最长回文 if (dp[i][j] && len > maxLen) { maxLen = len; start = i; } } } return s.substring(start, start + maxLen); } ``` ##### **复杂度分析** - 时间复杂度:$O(n^2)$ - 空间复杂度:$O(n^2)$(二维DP表) **适用场景**:需要多次查询子串回文性的场景 --- #### **四、中心扩展法(最优解)** ##### **核心思路** - 每个回文的中心可能是一个字符(奇长度)或两个字符(偶长度) - 从每个可能的中心向两侧扩展,寻找最长回文 ##### **代码实现** ```java public String longestPalindrome(String s) { if (s == null || s.length() < 1) return ""; int start = 0, end = 0; for (int i = 0; i < s.length(); i++) { // 处理奇数长度回文(中心为单个字符) int len1 = expandAroundCenter(s, i, i); // 处理偶数长度回文(中心为两个相同字符) int len2 = expandAroundCenter(s, i, i + 1); int maxLen = Math.max(len1, len2); if (maxLen > end - start) { start = i - (maxLen - 1) / 2; end = i + maxLen / 2; } } return s.substring(start, end + 1); } // 从中心向两侧扩展 private int expandAroundCenter(String s, int left, int right) { while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) { left--; right++; } return right - left - 1; // 实际回文长度 = (right-1) - (left+1) + 1 } ``` ##### **复杂度分析** - 时间复杂度:$O(n^2)$(每个字符作为中心扩展两次) - 空间复杂度:$O(1)$ **实际效率**:比动态规划快约2倍(避免了二维数组操作) --- #### **五、三种方法对比** | 方法 | 时间复杂度 | 空间复杂度 | 优势 | 局限性 | |--------------|------------|------------|--------------------------|--------------------------| | **暴力法** | $O(n^3)$ | $O(1)$ | 实现简单 | 无法处理长度 >100 的输入 | | **动态规划** | $O(n^2)$ | $O(n^2)$ | 可复用中间结果 | 空间占用高 | | **中心扩展** | $O(n^2)$ | $O(1)$ | 空间最优,实际运行最快 | 无 | --- #### **六、边界条件测试用例** 1. **空字符串** ```java Input: "" → Output: "" ``` 2. **全相同字符** ```java Input: "aaaaa" → Output: "aaaaa" ``` 3. **最长回文在末尾** ```java Input: "abcbcbd" → Output: "bcbcb" ``` --- ### **总结** - **推荐方案**:优先选择**中心扩展法**,兼顾时间空间效率 - **扩展思考**:Manacher算法可将时间复杂度优化到$O(n)$,但实现较复杂,适用于超长字符串(如长度 ≥ $10^6$)
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值