1627--Krypton Factor

Problem Description

---

You have been employed by the organisers of a Super Krypton Factor Contest in which contestants have very high mental and physical abilities. In one section of the contest the contestants（选手） are tested on their ability to recall a sequenace of characters which has been read to them by the Quiz Master. Many of the contestants are very good at recognising patterns(识别模式). Therefore, in order to add some difficulty to this test, the organisers have decided that sequences containing certain types of repeated subsequences should not be used. However, they do not wish to remove all subsequences that are repeated, since in that case no single(单一的) character could be repeated. This in itself would make the problem too easy for the contestants. Instead it is decided to eliminate(消除，排除) all sequences containing an occurrence(出现) of two adjoining(临接的) identical(同一的) subsequences. Sequences containing such an occurrence will be called easy''. Other sequences will be calledhard”.

For example, the sequence ABACBCBAD is easy, since it contains an adjoining repetition of the subsequence CB. Other examples of easy sequences are:

BB
ABCDACABCAB
ABCDABCD

Some examples of hard sequences are:

D
DC
ABDAB
CBABCBA

Input
In order to provide the Quiz Master with a potentially(可能的) unlimited source of questions you are asked to write a program that will read input lines that contain integers n and L (in that order), where n > 0 and L is in the range(范围) , and for each input line prints out the nth hard sequence (composed of letters drawn from the first L letters in the alphabet), in increasing alphabetical order (alphabetical ordering here corresponds to the normal ordering encountered in a dictionary(字典序)), followed (on the next line) by the length of that sequence. The first sequence in this ordering is A. You may assume that for given n and L there do exist at least n hard sequences.

For example, with L = 3, the first 7 hard sequences are:

A
AB
ABA
ABAC
ABACA
ABACAB
ABACABA
As each sequence is potentially very long, split it into groups of four (4) characters separated by a space. If there are more than 16 such groups, please start a new line for the 17th group.

Therefore, if the integers 7 and 3 appear on an input line, the output lines produced should be

ABAC ABA
7
Input is terminated by a line containing two zeroes. Your program may assume a maximum sequence length of 80.

Sample Input
30 3
0 0

Sample Output
ABAC ABCA CBAB CABA CABC ACBA CABA
28

Source
uva

---

problem of processing

---

首先总体思路，一个个枚举试探。

按宇哥的话来说，就是能不能放，放了再说，哈哈，很经典，在这也很适用。

就比如说A,之后可以放ABC…..，能不能放A,先放了再说，然后检测一下放了之后，会不会违背重复串，即题目的意思。

为什么按ABC…的顺序来放，应为题目要求的是字典序最小。

那么接下来的问题就是检测放了之后的字符串是否重复？最笨 的方法就是，将所有相邻的偶数串一一检测，（为啥奇数串不用检测，自己去想）

怎么检测？首先将长度为一的所有相邻检测，然后长度为2，依次下去，直到长度为总串的一半。 这个是最笨的办法，用的话，可能会T
接下来，可以不用检测那么多。首先思考一个八皇后的检测方法。这里很类似。

假设串a1a2.。。。ai都已经放好了，并且没有重复，那么放a(i+1)之后，只需检测后一半的长度。即a(i+1)到a(i+1)/2,画个图就明白了。然后检测还是先按1长度检测，然后2.依次类推。

---

coding

---

#include<iostream>
#include<cstring>
using namespace std;
const int maxn = 81;
int ch[maxn];
int n,L,cnt;

int dfs(int cur)
{
    if(cnt++ == n)
    {
        int index = 0,tot=0;//index控制每组四个
        //tot控制有是否到16组
        for(int i=0; i<cur; ++i)
        {
            cout << (char)(ch[i]+'A');
            index++;
            if(index == 4)
             {
                 index = 0;
                 tot++;
                 //如果是第16组并且还有字符，则回车
                 if(tot==16 && i!=cur-1)
                 {
                     cout << endl;
                     tot = 0;
                 }else
                 {
                     if(i != cur-1) //若果还有字符才空格
                        cout << ' ';
                 }
             }
        }
        cout << endl << cur << endl;
        return 0;
    }
    for(int i=0; i<L; ++i)
    {
        ch[cur] = i;

        int label = 1; //假设没有重复串
        for(int j=1; j*2<=cur+1; ++j)
        {
            int ok = 1; //假设比较的俩个分串相等
            for(int k=0; k<j; ++k)
            {
                if(ch[cur-k]!=ch[cur-k-j])
                {
                    ok = 0; //则不相等
                    break;
                }
            }
            if(ok) //如果相等，则不用比了
            {
                label = 0; //说明有重复串
                break;
            }
        }
        if(label)
        {
           if(!dfs(cur+1))
             return 0;
        }
    }
    return 1;
}
int main()
{
    int m;
    while(cin >> n >> L )
    {
        if(!n && !L)
            break;
        cnt = 0;
        dfs(0);
    }
    return 0;
}

---