最长合成字串

本文介绍了一个算法问题,即如何从一组单词中找到可以由其他单词组成(可重复使用)的最长单词,并给出了Java实现代码。该算法首先对单词按长度降序排序,然后逐个检查每个单词是否能由更短的单词组成。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

有一组单词,请编写一个程序,在数组中找出由数组中字符串组成的最长的串A,即A是由其它单词组成的(可重复)最长的单词。
给定一个string数组str,同时给定数组的大小n。请返回最长单词的长度,保证题意所述的最长单词存在。
测试样例:
[“a”,”b”,”c”,”ab”,”bc”,”abc”],6
返回3
[“a”,”b”,”ab”,”abc”],4
返回2

import java.util.*;
public class LongestString {
    public int getLongest(String[] str, int n) {
        if (str == null || str.length == 0) {
            return 0;
        }
        //先对数组中的字符串按照长度进行排序
        Arrays.sort(str, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.length() - o1.length();
            }
        });
        //此时数组中的元素是按照字符串的长度排序的,长度大的在前面,长度小的在后面
        //假如上面是o1.length()-o2.length(),则长度短的在前面,长度长的在后面
        for(int i=0;i<n;i++){
            if(canBuild(str,str[i],i)){
                return str[i].length();
            }
        }
        return 0;
    }
    //str表示字符串数组,s表示str字符串数组中的一个元素,它是一个字符串,index,是为了在第一次判断的时候s.contains(str[i])的时候去掉自身与自身的判断。
    public boolean canBuild(String[]str,String s,int index){
        if(s==null||s.length()==0){//递归的结束条件,当s为null或者长度为0时,直接返回true;
            return true;
        }
        for(int i=0;i<str.length;i++){
            if(i!=index){//这个判断条件只在第一次调用时有效,在下一次递归的过程中其实不用判断,
                if(s.contains(str[i])){
//s.substring(str[i].length())相当于字符串s后半段元素组成的字符串                    if(canBuild(str,s.substring(str[i].length()),index)){
                        return true;
                    }
                }
            }
        }
        return false;
    }
}
### Java 实现查找最长回文子字符串 以下是基于 Manacher 算法的 Java 实现,用于查找给定字符串中的最长回文子串: ```java public class LongestPalindrome { public static String longestPalindrome(String s) { if (s == null || s.length() == 0) return ""; // 预处理字符串,在每个字符之间插入 '#' StringBuilder processedStr = new StringBuilder("#"); for (char c : s.toCharArray()) { processedStr.append(c).append("#"); } int[] p = new int[processedStr.length()]; int center = 0, mirror = 0; int maxLen = 0, maxCenter = 0; for (int i = 0; i < processedStr.length(); i++) { mirror = 2 * center - i; if (i < center + p[center]) { p[i] = Math.min(center + p[center] - i, p[mirror]); } while (i + (p[i] + 1) < processedStr.length() && i - (p[i] + 1) >= 0 && processedStr.charAt(i + (p[i] + 1)) == processedStr.charAt(i - (p[i] + 1))) { p[i]++; } if (i + p[i] > center + p[center]) { center = i; } if (p[i] > maxLen) { maxLen = p[i]; maxCenter = i; } } int start = (maxCenter - maxLen) / 2; return s.substring(start, start + maxLen); } public static void main(String[] args) { System.out.println(longestPalindrome("babad")); // 输出 "bab" 或 "aba" System.out.println(longestPalindrome("cbbd")); // 输出 "bb" } } ``` #### 方法解析 上述代码实现了 Manacher 算法的核心逻辑。该算法通过对输入字符串进行预处理[^1],在每个字符间插入特殊符号 `#` 来统一处理奇数长度和偶数长度的回文子串。随后利用中心扩展的思想并借助辅助数组 `p` 记录每个位置的最大回文半径[^2]。 对于每一个位置 \(i\) 的回文半径计算,如果当前位置处于之前已知的最大回文范围之内,则可以通过镜像关系减少不必要的比较操作;否则直接尝试扩展边界直到不满足回文条件为止[^3]。 最终通过记录最大回文半径及其对应的中心位置,可以从原字符串中提取出最长的回文子串[^4]。 --- ### 动态规划实现方式 除了 Manacher 算法外,还可以采用动态规划的方式解决此问题。下面是另一种基于动态规划的解决方案: ```java public class LongestPalindromeDP { public static String longestPalindrome(String s) { if (s == null || s.length() <= 1) return s; int n = s.length(); boolean[][] dp = new boolean[n][n]; int maxLength = 1; int start = 0; // 单个字符都是回文 for (int i = 0; i < n; i++) { dp[i][i] = true; } // 判断两个连续字符是否为回文 for (int i = 0; i < n - 1; i++) { if (s.charAt(i) == s.charAt(i + 1)) { dp[i][i + 1] = true; start = i; maxLength = 2; } } // 考虑更长的子串 for (int length = 3; length <= n; length++) { for (int i = 0; i < n - length + 1; i++) { int j = i + length - 1; if (s.charAt(i) == s.charAt(j) && dp[i + 1][j - 1]) { dp[i][j] = true; start = i; maxLength = length; } } } return s.substring(start, start + maxLength); } public static void main(String[] args) { System.out.println(longestPalindrome("babad")); // 输出 "bab" 或 "aba" System.out.println(longestPalindrome("cbbd")); // 输出 "bb" } } ``` 在此方法中,我们定义了一个二维布尔型数组 `dp`,其中 `dp[i][j]` 表示从索引 \(i\) 到 \(j\) 的子串是否构成回文[^5]。初始状态设置单个字符均为回文,并逐步扩大子串长度直至覆盖整个字符串。 --- ### 性能对比 - **时间复杂度**: - Manacher 算法的时间复杂度为 O(n),因为它只需一次线性扫描即可完成所有必要的计算。 - 动态规划的时间复杂度为 O(n²),因为需要填充大小为 \(n \times n\) 的表格。 - **空间复杂度**: - Manacher 算法的空间复杂度为 O(n),只需要存储一个额外的一维数组。 - 动态规划的空间复杂度同样为 O(n²),由于其依赖于完整的二维矩阵。 因此,当面对较长的输入数据时,推荐优先考虑 Manacher 算法以获得更高的效率。 ---
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值