最长对称子串

//求一个字符串中最长对称字串，好像有点如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 != '')
       {
              // Substrings with odd length
              char* pFirst = pChar - 1;
              char* pLast = pChar + 1;
              while(pFirst >= pString && *pLast != '' && *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 != '' && *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;
}