Question

调试以下问题（递归解决方案）并混淆for循环的逻辑含义。如果有人有任何见解，欢迎分享。

给定字符串S，您可以通过在其前面添加字符将其转换为回文结构。通过执行此转换，找到并返回您可以找到的最短回文。

例如：

鉴于＆＃34; aacecaaa＆＃34;，返回＆＃34; aaacecaaa＆＃34;。

鉴于＆＃34; abcd＆＃34;，返回＆＃34; dcbabcd＆＃34;。

int j = 0;
for (int i = s.length() - 1; i >= 0; i--) {
    if (s.charAt(i) == s.charAt(j)) { j += 1; }
}
if (j == s.length()) { return s; }
String suffix = s.substring(j);
return new StringBuffer(suffix).reverse().toString() + shortestPalindrome(s.substring(0, j)) + suffix;

基于KMP的解决方案，

public class Solution {
    public String shortestPalindrome(String s) {
        String p = new StringBuffer(s).reverse().toString();
        char pp[] = p.toCharArray();
        char ss[] = s.toCharArray();
        int m = ss.length;
        if (m == 0) return "";

        // trying to find the greatest overlap of pp[] and ss[]
        // using the buildLPS() method of KMP
        int lps[] = buildLPS(ss);
        int i=0;// points to pp[]
        int len = 0; //points to ss[]

        while(i<m) {
            if (pp[i] == ss[len]) {
                i++;
                len++;
                if (i == m)
                    break;
            } else {
                if (len == 0) {
                    i++;
                } else {
                    len = lps[len-1];
                }
            }
        }
        // after the loop, len is the overlap of the suffix of pp and prefix of ss
        return new String(pp) + s.substring(len, m);

    }

    int [] buildLPS(char ss[]) {
        int m = ss.length;
        int lps[] = new int[m];
        int len = 0;
        int i = 1;
        lps[0] = 0;
        while(i < m) {
            if (ss[i] == ss[len]) {
                len++;
                lps[i] = len;
                i++;
            } else {
                if (len == 0) {
                    i++;
                } else {
                    len = lps[len-1];
                }

            }
        }

        return lps;
    }
}

提前谢谢，林

Answer 1

我的原始评论不正确 - 正如您所指出的那样，除了使用j'检查s是否是完整的回文，j也用于查找（聪明地猜测？）索引周围的索引，从最长的回文中包含可能存在于字符串开头的尾随字符。我对算法的理解如下：

e.g。 aacecaaa提供j = 7，结果为

`aacecaaa` is `aacecaa` (palindrome) + `a` (suffix)

所以最开始的最短回文是：

`a` (suffix) + `aacecaa` + `a` (suffix)

如果后缀由多个字符组成，则必须将其反转：

`aacecaaab` is `aacecaa` (palindrome) + `ab` (suffix)

所以这种情况下的解决方案是：

`ba` + `aacecaa` + `ab` (suffix)

在最糟糕的情况下j = 1（因为a将在i=0和j=0）时匹配，例如abcd中没有回文序列，所以可以做的最好的事情就是环绕第一个字符

dcb + a + bcd

说实话，我并非100％确信您正在调试的算法在所有情况下都能正常工作，但似乎无法找到失败的测试用例。该算法当然不直观。

修改

我认为可以确定性地导出最短的Palindrome，而根本不需要递归 - 似乎在你正在调试的算法中，递归掩盖了j值的副作用。在我看来，这是一种以更直观的方式确定j的方法：

private static String shortestPalindrome(String s) { int j = s.length(); while (!isPalindrome(s.substring(0, j))) { j--; } String suffix = s.substring(j); // Similar to OP's original code, excluding the recursion. return new StringBuilder(suffix).reverse() .append(s.substring(0, j)) .append(suffix) .toString(); }

我在Ideone here上粘贴了一些isPalindrome实施的测试用例

Answer 2

public String shortestPalindrome(String s) {
   String returnString ="";
   int h = s.length()-1;
    if(checkPalindrome(s))
    {
        return s;
    }
    while(h>=0)
    {
       returnString =returnString + s.charAt(h);
       if(checkPalindrome(returnString+s))
       {
           return returnString+s;
       }
        h--;
             
    }
    return returnString+s;
       
}

public boolean checkPalindrome(String s)
{
    int midpoint = s.length()/2;
    // If the string length is odd, we do not need to check the central character
    // as it is common to both
    return (new StringBuilder(s.substring(0, midpoint)).reverse().toString()
            .equals(s.substring(s.length() - midpoint)));
}

具有递归解决方案问题的最短回文

2 个答案: