leetcode第五题——寻求最长回文子串

1.思路：

　　1.暴力解法：

　　　　直接遍历，两头收缩。

　　

class Solution {
    public String longestPalindrome(String s) {
       int len=s.length();
       if(len<2){
           return s;
       }
       int maxlen=1;
       int begin=0;
       char[] charArray=s.toCharArray();
       for(int i=0;i<charArray.length;i++){
           for(int j=i+1;j<charArray.length;j++){
               if(j-i+1>maxlen&&validPalidrome(charArray,i,j)){
                   maxlen=j-i+1;
                   begin=i;
               }
           }
       }

       return s.substring(begin,begin+maxlen);
    }
    /*验证是否为回文串,
    从外部验证，两边开始逐渐缩小



    */
    private boolean validPalidrome(char[] charArray,int left,int right){
        while(left<right){
            if(charArray[left] != charArray[right]){
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
   
    
}

　　时间复杂度：O(n^3)

　　空间复杂度：O（1）

　　##注意：回文子串的长度必须大于2

　　2.动态规划解法

　　　　动态规划思路：可以考虑将数组头尾相同考虑为true,不同设置为false,接下来逐级深入。

　　　　最终缩小至最中心。

　　　　将回文串转义为二维数组，并赋值状态，如果不等改变状态，如果相等继续下一级首尾继续。

　　　　当j-i<3或者j=i时，如果chars[i]=chars[j],则状态为true.

　　　　时间复杂度为O（n^2）,空间复杂度为O（n^2）.

　　　　

class Solution {
    public String longestPalindrome(String s) {
       int len=s.length();
       if(len<2){
           return s;
       }
       
       
       int maxlen=1;
       int begin=0;

      /*
        步骤1：定义状态

      */
      boolean[][] dp=new boolean[len][len];
      for(int i=0;i<len;i++){
          dp[i][i]=true;
      }
        /*
        步骤二：开始遍历



        */
        char[] chars=s.toCharArray();
      for(int j=1;j<len;j++){
          for(int i=0;i<j;i++){
              if(chars[i]!=chars[j]){
                dp[i][j]=false;
              }else{
                if(j-i<3){
                    dp[i][j]=true;
                }else{
                  dp[i][j]=dp[i+1][j-1];  
                
                }
                if(j-i+1>maxlen&&dp[i][j]){
                    maxlen=j-i+1;
                    begin=i;
                
                }


              }
          }
      }
       
      
        
           
               
       
       /*

        substring左闭右开
       */

       return s.substring(begin,begin+maxlen);
    }
    /*验证是否为回文串,
    从外部验证，两边开始逐渐缩小



    */
    
   
    
}

　　3.中心扩散法　

　　　　

class Solution {
    public String longestPalindrome(String s) {
       int len=s.length();
       if(len<2){
           return s;
       }
       
       
       char[] charArray=s.toCharArray();
       /*
            中心扩散法：时间复杂度为O（n^2）,空间复杂度为O（1），不需要复杂空间

       */
       int end=0;
       int begin=0;
       for(int i=0;i<s.length();i++){
        
            int len1=expandPalidrome(s,i,i);
            int len2=expandPalidrome(s,i,i+1);
            int length=Math.max(len1,len2);
            if(length>end-begin){
               begin=i-(length-1)/2;
                end=i+length/2; 
            }
               
       }
       /*

        substring左闭右开
       */

       return s.substring(begin,end+1);
    }
    /*验证是否为回文串,
    从外部验证，两边开始逐渐缩小



    */
    private int expandPalidrome(String s,int left,int right){
        int L=left,R=right;
        //当条件不相等时，跳出循环，所以长度为R-L+1-2
        while(L>=0 && R<s.length()&&s.charAt(L)==s.charAt(R)){
            R++;
            L--;
        }
        return R-L-1;
    }
   
    
}