POJ1780 Code 欧拉回路+非递归DFS

用DFS找一个欧拉回路，按照字典序输出路径。

由于状态过多，不能用递归，要用非递归实现DFS（好麻烦，，，），然后不能用stack会超时，自己写个数组吧，别偷懒了。

关于这题为什么会是欧拉回路呢。

首先题意:题目告诉我们了密码的长度为n （那么一个密码一共可能有10^n种可能），然后由于当输入密码长度大于n时，只有最后n为有效。这样我们只要用一个（10^n+n-1）长的数字序列，就能破解这个密码。至于为什么是这个长度，那是因为一共有10^n个状态分别拿出第一个数字排列下去，然后最后一个密码会多出n-1位。直接放在后面。这样实际上这个序列就是一个欧拉回路，它实际包含了10^n个密码（每个状态都出现了一次）；

关于边与节点的定义。 加入密码为3位

那么我们的节点为前2为数，然后边会在前两位数后加上一个数形成的完整密码，然后后继点为新密码的后两位。

最后一共会有10^n条边，我们要找一个通路走完每一条边，也就是说每个密码状态都要出现一次，

这个题目实际上就是欧拉回路的旋转鼓轮的应用。

                 

Code

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 1694		Accepted: 638

Description

KEY Inc., the leading company in security hardware, has developed a new kind of safe. To unlock it, you don't need a key but you are required to enter the correct n-digit code on a keypad (as if this were something new!). There are several models available, from toy safes for children (with a 2-digit code) to the military version (with a 6-digit code). 

The safe will open as soon as the last digit of the correct code is entered. There is no "enter" key. When you enter more than n digits, only the last n digits are significant. For example (in the 4-digit version), if the correct code is 4567, and you plan to enter the digit sequence 1234567890, the door will open as soon as you press the 7 key. 

The software to create this effect is rather simple. In the n-digit version the safe is always in one of 10 ^n-1 internal states. The current state of the safe simply represents the last n-1 digits that have been entered. One of these states (in the example above, state 456) is marked as the unlocked state. If the safe is in the unlocked state and then the right key (in the example above, 7) is pressed, the door opens. Otherwise the safe shifts to the corresponding new state. For example, if the safe is in state 456 and then you press 8, the safe goes into state 568. 

A trivial strategy to open the safe is to enter all possible codes one after the other. In the worst case, however, this will require n * 10 ⁿ keystrokes. By choosing a good digit sequence it is possible to open the safe in at most 10 ⁿ + n - 1 keystrokes. All you have to do is to find a digit sequence that contains all n-digit sequences exactly once. KEY Inc. claims that for the military version (n=6) the fastest computers available today would need billions of years to find such a sequence - but apparently they don't know what some programmers are capable of...

Input

The input contains several test cases. Every test case is specified by an integer n. You may assume that 1<=n<=6. The last test case is followed by a zero.

Output

For each test case specified by n output a line containing a sequence of 10 ⁿ + n - 1 digits that contains each n-digit sequence exactly once.

Sample Input

1
2
0

Sample Output

0123456789
00102030405060708091121314151617181922324252627282933435363738394454647484955657585966768697787988990

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
#include<utility>
#include<vector>

using namespace std;

#define MAXN 1000000+100

struct node
{
    int v,id,next;
}edge[MAXN];

struct data
{
    int v,e;
}s[MAXN];

bool vis[MAXN];
int path[MAXN],top,st;
int head[MAXN],en;
int n;

void add(int u,int v,int id)
{
    edge[en].v=v;
    edge[en].id=id;
    edge[en].next=head[u];
    head[u]=en++;
}

void dfs(int u)
{
    data p;
    st=0;
    int t=head[u];
    p.v=u,p.e=t;
    s[st++]=p;
    vis[edge[t].id]=1;
    while(1)
    {
        if(t==-1)
        {
            data y=s[st-1];
            path[top++]=edge[y.e].id;
            st--;
            if(!st) break;

        }
        data x=s[st-1];
        t=head[x.v];
        while(t!=-1)
        {
            if(!vis[edge[t].id])
            {
                vis[edge[t].id]=1;
                p.v=edge[t].v,p.e=t;
                s[st++]=p;
                break;
            }
            t=edge[t].next;
        }
    }

}


int main()
{
    while(~scanf("%d",&n) && n)
    {
        if(n==1)
        {
            printf("0123456789\n");
            continue;
        }
        int cnt=1;//计算边数（状态）
        for(int i=1;i<=n;i++)
            cnt*=10;
        int len=cnt/10;//节点数
         memset(head,-1,sizeof(head)),en=0;
        for(int i=0;i<len;i++)
        {
            int tmp=i%(len/10);
            tmp*=10;
            for(int j=9;j>=0;j--)
            {
                add(i,tmp+j,i*10+j);
               // cout<<i*10+j<<endl;
            }
        }
        memset(vis,0,sizeof(vis));
        top=0;
        dfs(0);
        for(int i=top-1;i>0;i--)
            printf("%d",path[i]/(len));
        printf("%d\n",path[0]);
    }
    return 0;
}