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 = (26*26*26);
const int mod = (26*26);
const int maxm = 500005;
bool vis[maxn][26];

int get_next(int now,int i)
{
    return (now%mod)*26+i;
}
int cur[maxn];
struct node
{
    int n,c;
}st[maxm];
char ans_str[maxm];
int str_len;
void euler(int now)
{
    int top=0;
    memset(cur,0,sizeof(cur));
    memset(vis,0,sizeof(vis));
    do
    {
        bool ff=false;
        for(int i=cur[now];i<26;++i)
        {
            if(vis[now][i])continue;
            vis[now][i]=true;
            cur[now]=i+1;
            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=0;
    euler(0);
    for(int i=0;i<3;++i)
        ans_str[str_len++]='a';
    ans_str[str_len]=0;
}
int main()
{
    init();
    int n;
    while(~scanf("%d",&n))
    {
        if(n>str_len)
            puts("Impossible");
        else
        {
            for(int i=0;i<n;++i)
                printf("%c",ans_str[i]);
            puts("");
        }
    }
    return 0;
}