HDU 4850 Wow! Such String!

链接：http://acm.hdu.edu.cn/showproblem.php?pid=4850

题意：给定一个N(1 ≤ N ≤ 500000)，构造一个长度为N的小写字母字符串，要求所有长度大于等于4的子串只能出现一次。不能构造输出“Impossible”。

(1).只需要考虑长度等于4的子串的情况。

(2).长度为4的小写字母子串组合共有26^4种，故最长只可能构造出26^4+3长度的字符串。

(3).若一个一个添加字符，当N>3时，每次添加一个字符，末尾的三个字符和新的字符就会构成一个新的长度为4的子串。

(4).抽象出图的模型：末尾的3个字符共有26^3种组合，每种抽象成一个节点。每个节点添加新字符有26种情况，抽象成26条有向边，指向转化后的节点。每经过一条图中的边，就是构造一个长度为4的子串的过程。如果长度为4的子串不能重复，那么每条边就至多只能走一次。

(5).图中每个节点的出度和入度都是26，根据定理，该有向图存在欧拉回路，且可以从任意一点作为出发点。那么图中所有的边都可以走过一次，构造出长度为26^4+3的字符串。

有向图欧拉回路的求法可以用套圈算法，写成非递归的形式，递归的形式会爆栈。

 #include <cstdio>
 #include <cstring>

 using namespace std;

 const int maxn = (**);
 const int mod = (*);
 const int maxm = ;
 bool vis[maxn][];

 int get_next(int now,int i)
 {
     return (now%mod)*+i;
 }
 int cur[maxn];
 struct node
 {
     int n,c;
 }st[maxm];
 char ans_str[maxm];
 int str_len;
 void euler(int now)
 {
     int top=;
     memset(cur,,sizeof(cur));
     memset(vis,,sizeof(vis));
     do
     {
         bool ff=false;
         for(int i=cur[now];i<;++i)
         {
             if(vis[now][i])continue;
             vis[now][i]=true;
             cur[now]=i+;
             now=get_next(now,i);
             st[++top].n=now;
             st[top].c=i;
             ff=true;
             break;
         }
         if(!ff)
         {
             ans_str[str_len++]=st[top].c+'a';
             now=st[--top].n;
         }
     }while(top);
 }

 void init()
 {
     str_len=;
     euler();
     for(int i=;i<;++i)
         ans_str[str_len++]='a';
     ans_str[str_len]=;
 }
 int main()
 {
     init();
     int n;
     while(~scanf("%d",&n))
     {
         if(n>str_len)
             puts("Impossible");
         else
         {
             for(int i=;i<n;++i)
                 printf("%c",ans_str[i]);
             puts("");
         }
     }
     return ;
 }