//求一個字符串中最長對稱字串，好像有點如google，那麽輸出goog

/*
O（n2）的算法
如果我們換一種思路，我們從裏向外來判斷。也就是我們先判斷子字符串A是不是對稱的。
如果A不是對稱的，那麽向該子字符串兩端各延長一個字符得到的字符串肯定不是對稱的。
如果A對稱，那麽我們只需要判斷A兩端延長的一個字符是不是相等的，如果相等，則延長後的字符串是對稱的。
因此在知道A是否對稱之後，只需要O（1）的時間就能知道aAa是不是對稱的。
*/

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include 
 
<string>
using namespace std;




bool IsSymmetrical(char* pBegin, char* pEnd);
void GetLongestSymmetricalLength_2(char* pString);


void GetLongestSymmetricalLength(char* pString);

void main()
{
    char c[30];
    gets_s(c);

    //string s;
    //while(cin>>s){
    //const char* c = s.c_str();

    
 
//GetLongestSymmetricalLength(c);
    //}


    GetLongestSymmetricalLength_2(c);
    system("pause");
}

void GetLongestSymmetricalLength(char* pString)
{
       if(pString == NULL)
              return;
 
       int symmeticalLength = 1;
      
       char* pChar = pString;
       while(*pChar != ‘\0‘)
       {
              
 
// Substrings with odd length
              char* pFirst = pChar - 1;
              char* pLast = pChar + 1;
              while(pFirst >= pString && *pLast != ‘\0‘ && *pFirst == *pLast)
              {
                     pFirst--;
                     pLast++;
              }
 
              int newLength = pLast - pFirst - 1;
              if(newLength > symmeticalLength)
                     symmeticalLength = newLength;
 
              // Substrings with even length
              pFirst = pChar;
              pLast = pChar + 1;
              while(pFirst >= pString && *pLast != ‘\0‘ && *pFirst == *pLast)
              {
                     pFirst--;
                     pLast++;
              }
 
              newLength = pLast - pFirst - 1;
              if(newLength > symmeticalLength)
                     symmeticalLength = newLength;
 
              pChar++;
       }
 
        cout<<symmeticalLength<<endl;
}


//方法2
//先判斷字符串是否對稱
//現在我們試著來得到對稱子字符串的最大長度。最直觀的做法就是得到輸入字符串的所有子字符串，並逐個判斷是不是對稱的。
//如果一個子字符串是對稱的，我們就得到它的長度。這樣經過比較，就能得到最長的對稱子字符串的長度了。


//先判斷字符串是否對稱
bool IsSymmetrical(char* pBegin, char* pEnd)
{
       if(pBegin == NULL || pEnd == NULL || pBegin > pEnd)
              return false;
 
       while(pBegin < pEnd)
       {
              if(*pBegin != *pEnd)
                     return false;
 
              pBegin++;
              pEnd --;
       }
 
       return true;
}


void GetLongestSymmetricalLength_2(char* pString)
{
       if(pString == NULL)
              return;
 
       int symmeticalLength = 1;
 
       char* pFirst = pString;
       int length = strlen(pString);
       while(pFirst < &pString[length - 1])
       {
              char* pLast = pFirst + 1;
              while(pLast <= &pString[length - 1])
              {
                     if(IsSymmetrical(pFirst, pLast))
                     {
                           int newLength = pLast - pFirst + 1;
                           if(newLength > symmeticalLength)
                                  symmeticalLength = newLength;                         
                     }
 
                     pLast++;
              }
 
              pFirst++;
       }
 
       cout<<symmeticalLength<<endl;
}

最長對稱子串