Java 带字符回文的最长字符串

学校作业中的问题描述 带回文的最长字符串

我得到了O（N^2）的复杂性。如何实现O（N*log（N））**

我的代码

int maxL = 0;
    for (int i = 0; i < S.length(); i++) {
        String currentString = String.valueOf(S.charAt(i));
        for (int j = i + 1; j < S.length(); j = j + 1) {
            String jStr = String.valueOf(S.charAt(j));
            if (currentString.contains(jStr)) {
                currentString = currentString.replace(jStr, "");
                int len = j - i + 1;
                if (currentString.length() == 0 && maxL < len) {
                    maxL = len;
                }
            } else {
                currentString = currentString + jStr;
            }
        }
    }
    return maxL;

intmaxl=0；
对于（int i=0；i

这个问题可以用O（n）空间在O（n）时间内解决。以下算法使用一个位集来跟踪从给定字符串开头开始的子字符串的不平衡字符。它只通过字符串一次，并记住它在哈希映射中已经看到的状态。每当我们第二次看到相同的状态时，就会发现一个有效的密码：只需从当前子字符串的开头删除旧的较短的子字符串

private static int index(char c) {
    if (c < '0') throw new IllegalArgumentException("illegal char");
    if (c <= '9') return c - '0';
    if (c < 'a') throw new IllegalArgumentException("illegal char");
    if (c <= 'z') return c - 'a' + 10;
    throw new IllegalArgumentException("illegal char");
}

private static int solution(String s) {
    HashMap<BitSet, Integer> states = new HashMap<>();
    int longest = 0;
    BitSet state = new BitSet();
    states.put((BitSet) state.clone(), 0);
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        state.flip(index(c));
        Integer seenAt = states.get(state);
        if (seenAt != null) {
            int len = i - seenAt + 1;
            if (len > longest) longest = len;
        } else {
            states.put((BitSet) state.clone(), i + 1);
        }
    }
    return longest;
}

私有静态int索引（char c）{
如果（c<'0'）抛出新的IllegalArgumentException（“非法字符”）；
如果（c），程序的最坏情况是O（n^3），而不是O（n^2），因为操作
currentString.contains（jStr）
可以是O（n）.@Henry Ooohhhh…谢谢。我认为那些Java方法运行得非常有效。我现在无法检查这个解决方案的复杂性，但它肯定比我的要少……非常感谢……位集对我来说是一个全新的东西