Java 计算字符串中最长的回文子字符串

我有以下代码来计算字符串中最长的回文子字符串。在线法官接受O（n^2）解，但我不知道为什么它不接受我的解，尽管我的算法复杂度似乎是O（n^2）`

class Ideone {

    public static void main(String args[]) {
        Ideone ob = new Ideone();
        String s = "sds";
        System.out.println(ob.longestPalindrome(s));

    }

    public String longestPalindrome(String s) {
        int maxlength = 1;

        String ps = s.charAt(0) + "";

        if (s.length() == 1)
            return s;
        for (int i = 0; i < s.length() - 1; i++) {
            int j = (s.substring(i + 1)).indexOf(s.charAt(i)) + i + 1;
            while (j < s.length() && j > i) {
                if (j - i + 1 > maxlength && check(s.substring(i, j + 1))) {

                    maxlength = j - i + 1;
                    ps = s.substring(i, j + 1);

                }
                if ((s.substring(j + 1)).indexOf(s.charAt(i)) < 0) {
                    break;
                }
                j = (s.substring(j + 1)).indexOf(s.charAt(i)) + j + 1;

            }
        }


        return ps;
    }

    public boolean check(String s) {
        int l = s.length();
        if (l == 1)
            return false;
        int t = l / 2;
        String s1, s2;
        if (l % 2 == 0) {
            s1 = s.substring(0, t);
            s2 = s.substring(t);

        } else {
            s1 = s.substring(0, t);
            s2 = s.substring(t + 1);

        }

        s2 = (new StringBuffer(s2)).reverse().toString();

        if (s1.compareTo(s2) == 0)
            return true;
        else return false;
    }

}

类表意符{
公共静态void main（字符串参数[]）{
Ideone ob=新Ideone（）；
字符串s=“sds”；
System.out.println（ob.longestPalindrome（s））；
}
公共字符串最长回文（字符串s）{
int maxlength=1；
字符串ps=s.charAt（0）+“”；
如果（s.长度（）==1）
返回s；
对于（int i=0；ii）{
如果（j-i+1>maxlength&&check（s.substring（i，j+1）））{
最大长度=j-i+1；
ps=s.子串（i，j+1）；
}
if（（s.substring（j+1））.indexOf（s.charAt（i））<0）{
打破
}
j=（s.substring（j+1））.indexOf（s.charAt（i））+j+1；
}
}
返回ps；
}
公共布尔检查（字符串s）{
int l=s.长度（）；
如果（l==1）
返回false；
int t=1/2；
字符串s1、s2；
如果（l%2==0）{
s1=s.子串（0，t）；
s2=s.子串（t）；
}否则{
s1=s.子串（0，t）；
s2=s.子串（t+1）；
}
s2=（新的StringBuffer（s2））.reverse（）.toString（）；
如果（s1.与（s2）==0相比）
返回true；
否则返回false；
}
}

首先，两个循环和一个需要O（n）来反转字符串的方法check（）可能会导致O（n³）

请注意以下方法：

• String.indexOf（..）
• String.substring（..）
• String.compareTo（..）
• StringBuffer.reverse（…）
• String.toString（）

---

需要对数据进行迭代，因此需要大约O（n）而不是恒定时间。

看起来需要超过O（n2）。下面是动态编程的程序代码。。不是java，但作为算法会很有用

---

检查您的代码是否为0（n²）？创建一个表并绘制一个运行时间图。非常感谢。这对我来说很有效。现在我能够找出我的算法不被接受的原因。reverse（）不是String的函数，而是StringBuffer的函数..我想澄清一下子字符串是否也需要线性时间？因为我认为它是一个常数时间函数？如果我错了请纠正我..thnx inadvance@RishabhNigam：根据子字符串的实现，子字符串的大小至少是线性的，因为此数据是复制来创建的新实例。我的回答不是给出一个昂贵方法的完整列表，而是关于必须考虑每个调用的方法来计算复杂度的备注。