【HDU1627】Krypton Factor（回溯法）

题目链接

Krypton Factor Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 622    Accepted Submission(s): 268   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 called ``hard''. 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

 

【题意】

定义困难的串为一个字符串中不含相同的子串，输入n，L，L表示前L个字母，如果L等于3，则用字母ABC，要求按给定格式输出第n小的困难的串，并且输出串的长度。

 

【解题思路】

拿到题目的第一想法肯定是检查所有长度为偶数的子串，分别判断每个子串的前一半是否等于后一半，虽然这样的想法是没错，但是会做很多无用功。

其实只需要判断当前串的后缀即可，即从当前串的最后一个字符开始往前判断长度为1-len/2的子串，因为以前一个字符为后缀在之前的步骤中已经判断过了。其实L=2时一共只有6个串，当L>=3时就很少回溯了，事实上，当L=3时可以构造出无限长的串，不存在相邻重复子串。 

 

【代码】

#include<bits/stdc++.h>
using namespace std;
const int maxn=100;
char s[maxn];
int n,l,cnt=0;
int judge(int len)
{
    for(int i=1;i<=len/2;i++)
    {
        int flag=0;
        for(int j=len;j>=len-i+1;j--)
        {
            if(s[j]!=s[j-i])
            {
                flag=1;
                break;
            }
        }
        if(!flag)return 0;
    }
    return 1;
}
void dfs(int cur)
{
    if(cnt==n)
    {
        for(int i=1;i<cur;i++)
        {
            printf("%c",s[i]);
            if(i%64==0 && i!=(cur-1))printf("\n");
            else if(i%4==0 && i!=(cur-1))printf(" ");
        }
        printf("\n%d\n",cur-1);
        return ;
    }
    if(cnt>n)return ;
    for(int i=0;i<l;i++)
    {
        s[cur]='A'+i;
        if(judge(cur))
        {
            cnt++;
            dfs(cur+1);
        }
    }
}
int main()
{
    while(~scanf("%d%d",&n,&l) && n && l)
    {
        cnt=0;
        dfs(1);
    }
    return 0;
}