Surprising Strings

The  D-pairs of a string of letters are the ordered pairs of letters that are distance D from each other. A string is  D-unique if all of its D-pairs are different. A string is  surprising if it is D-unique for every possible distance D.

Consider the string ZGBG. Its 0-pairs are ZG, GB, and BG. Since these three pairs are all different, ZGBG is 0-unique. Similarly, the 1-pairs of ZGBG are ZB and GG, and since these two pairs are different, ZGBG is 1-unique. Finally, the only 2-pair of ZGBG is ZG, so ZGBG is 2-unique. Thus ZGBG is surprising. (Note that the fact that ZG is both a 0-pair and a 2-pair of ZGBG is irrelevant, because 0 and 2 are different distances.)

Input: The input consists of one or more nonempty strings of at most 79 uppercase letters, each string on a line by itself, followed by a line containing only an asterisk that signals the end of the input.

Output: For each string of letters, output whether or not it is surprising using the exact output format shown below.

Acknowledgement: This problem is inspired by the "Puzzling Adventures" column in the December 2003 issue of Scientific American.

Example input:	Example output:
ZGBG X EE AAB AABA AABB BCBABCC *	ZGBG is surprising. X is surprising. EE is surprising. AAB is surprising. AABA is surprising. AABB is NOT surprising. BCBABCC is NOT surprising.

源代码：

#include<iostream>
#include<string>
#include<map>
using namespace std;

int main()
{
    string str;
    while(cin>>str&&str[0]!='*')
    { 
          if(str.size()<=2)           //长度小于2的字符串都是 Surprising Strings 
          {
               cout<<str<<" is surprising."<<endl;
          }
          else                        //长度大于2的 
          {
              map<string,bool>flag;
              string str2;
              bool mark=false;
              
              for(int d=1;d<str.size();++d)    //两个字符间的距离范围为1-str.size()-1 
              {
                    
                    for(int i=0;i+d<str.size();++i)    //从第一个字符才开始循环取出子字符串 
                    {
                          str2.push_back(str[i]);
                          str2.push_back(str[i+d]);
                          
                          if(!flag[str2])flag[str2]=true;
                          else 
                          {
                               mark=true;   //有相同的子串 
                               break;
                          }
                          str2.clear();     //要及时将子串清空 
                    }
                    flag.clear();           //要及时将flag清空，以免影响下一轮循环 
                    if(mark)break; 
              }
              if(!mark)cout<<str<<" is surprising."<<endl;
              else cout<<str<<" is NOT surprising."<<endl;
          }
    }
    return 0;
}