UVA 401 ACM 回文数

 #include<iostream>
#include<vector>
using namespace std;
typedef enum eJudgedState{NOTHER,BOTH,PALIND,MIRRORED};
struct stReversedWord
{
    char cOriginalWord;
    char cReversedWord;
};
bool IsPalind(string szJudgedStr)
{
    bool bIsPalind = true;
    if(szJudgedStr.size() % 2 == 0)
    {
        int iLeftMiddle = szJudgedStr.size() / 2 - 1;
        int iRightMiddle = szJudgedStr.size() /2 ;
        for(int iIndexI = 0;iIndexI <= iLeftMiddle;iIndexI++)
        {
            if(szJudgedStr.at(iLeftMiddle - iIndexI) != szJudgedStr.at(iRightMiddle + iIndexI))
            {
                bIsPalind = false;
            }   
        }   
    }
    else
    {
        int iMiddle = szJudgedStr.size() / 2;
        for(int iIndexI =0; iIndexI <= iMiddle; iIndexI++)
        {
            if(szJudgedStr.at(iMiddle - iIndexI) !=  szJudgedStr.at(iMiddle + iIndexI))
            {
                bIsPalind = false;
            }   
        }    
    }       
    return bIsPalind;
}
int FindStWord(vector<stReversedWord> stWord,char cDestCh)
{
    int iReturnIndex = stWord.size();
    for(int iIndexI = 0; iIndexI <  stWord.size();iIndexI++)
    {
       if(stWord.at(iIndexI).cOriginalWord == cDestCh)
       {
           iReturnIndex = iIndexI;
           break;
       }           
    }   
   
    return iReturnIndex;
}   
void ReverseWord(string& szMirrored,int iEndIndex,vector<stReversedWord> stWord)
{
   
     for(int iIndexI =0;iIndexI < iEndIndex; iIndexI++)
     {     
        int iFindIndex = FindStWord(stWord,szMirrored.at(iIndexI));   
        if( iFindIndex == stWord.size())
        {
            szMirrored="AB";
            return;
        }
        else
        {
            szMirrored.at(iIndexI) = stWord.at(iFindIndex).cReversedWord; 
        }       
     }
}   
bool IsMirrored(string szMirrored,vector<stReversedWord> stWord)
{
   
    bool bIsMirrored = true;
    if(szMirrored.size() % 2 ==0)
    {
         ReverseWord(szMirrored,szMirrored.size() / 2,stWord);  
    }
    else
    {
        ReverseWord(szMirrored,szMirrored.size() / 2 + 1,stWord);
    }       
   
    return IsPalind(szMirrored);
}       
eJudgedState JudgeString(bool bIsPalind,bool bIsMirrored)
{
    if(bIsPalind)
    {
        if(bIsMirrored)
        {
            return BOTH;
        }   
        else
        {
            return PALIND;
        }   
    }  
    else if(bIsMirrored)
    {
        return MIRRORED;
    }
    else
    {
        return NOTHER;
    }        
}   
void PrintJudged(eJudgedState eState,string szPrintStr)
{
    switch(eState)
    {
        case NOTHER:
            cout<<szPrintStr<<" -- is not a palindrome."<<endl;
            break;
        case BOTH:
            cout<<szPrintStr<<" -- is a mirrored palindrome." <<endl;
            break;
        case PALIND:
            cout<<szPrintStr<<" -- is a regular palindrome." <<endl;
            break;
        case MIRRORED:
            cout<<szPrintStr<<" -- is a mirrored string."<<endl;
            break;
        default:
            break;
    }   
    cout<<endl;
}   

// 这个初始化写的很不好，但数据没有规律没办法。
vector<stReversedWord> InitReveredWord()
{
    vector<stReversedWord> stWord;
    struct stReversedWord word;
    word.cOriginalWord = 'Z';
    word.cReversedWord = '5';
    stWord.push_back(word);
    word.cOriginalWord = '5';
    word.cReversedWord = 'Z';
    stWord.push_back(word);
    word.cOriginalWord = 'E';
    word.cReversedWord = '3';
    stWord.push_back(word);
    word.cOriginalWord = '3';
    word.cReversedWord = 'E';
    stWord.push_back(word);
    word.cOriginalWord = 'J';
    word.cReversedWord = 'L';
    stWord.push_back(word);
    word.cOriginalWord = 'L';
    word.cReversedWord = 'J';
    stWord.push_back(word); 
    word.cOriginalWord = '2';
    word.cReversedWord = 'S';
    stWord.push_back(word); 
    word.cOriginalWord = 'S';
    word.cReversedWord = '2';
    stWord.push_back(word);
    word.cOriginalWord = 'A';
    word.cReversedWord = 'A';
    stWord.push_back(word);
    word.cOriginalWord = 'H';
    word.cReversedWord = 'H';
    stWord.push_back(word); 
    word.cOriginalWord = 'I';
    word.cReversedWord = 'I';
    stWord.push_back(word); 
    word.cOriginalWord = 'M';
    word.cReversedWord = 'M';
    stWord.push_back(word); 
    word.cOriginalWord = 'O';
    word.cReversedWord = 'O';
    stWord.push_back(word); 
    word.cOriginalWord = 'T';
    word.cReversedWord = 'T';
    stWord.push_back(word); 
    word.cOriginalWord = 'U';
    word.cReversedWord = 'U';
    stWord.push_back(word); 
    word.cOriginalWord = 'V';
    word.cReversedWord = 'V';
    stWord.push_back(word); 
    word.cOriginalWord = 'W';
    word.cReversedWord = 'W';
    stWord.push_back(word); 
    word.cOriginalWord = 'X';
    word.cReversedWord = 'X';
    stWord.push_back(word); 
    word.cOriginalWord = 'Y';
    word.cReversedWord = 'Y';
    stWord.push_back(word); 
    word.cOriginalWord = '1';
    word.cReversedWord = '1';
    stWord.push_back(word); 
    word.cOriginalWord = '8';
    word.cReversedWord = '8';
    stWord.push_back(word); 
       return stWord;
   
}   
int main()
{
    string szJudgedStr("");
    vector<stReversedWord> stWord = InitReveredWord();
       
    while((cin>>szJudgedStr))
    {
       if(szJudgedStr.size() == 1)
       {
          int iFindIndex = FindStWord(stWord,szJudgedStr.at(0));
          if(iFindIndex == stWord.size())
          {
              cout<<szJudgedStr<<" -- is a regular palindrome." <<endl<<endl;
          }  
          else if(stWord.at(iFindIndex).cOriginalWord == stWord.at(iFindIndex).cReversedWord)
          {
              cout<<szJudgedStr<<" -- is a mirrored palindrome." <<endl<<endl;
             
          }           
          else
          {
              cout<<szJudgedStr<<" -- is a regular palindrome." <<endl<<endl;
          }   
       }
       else
       {   
         bool bIsPalind   = IsPalind(szJudgedStr);
         bool bIsMirrored = IsMirrored(szJudgedStr,stWord);
         eJudgedState eState = JudgeString(bIsPalind,bIsMirrored);
         PrintJudged(eState,szJudgedStr);
       }                 
    }   
   
    return 0;
}