2017计算机学科夏令营上机考试D：Safecracker（DFS+回溯）

题意

Klein语句通常包含5到12个不同的大写字母，通常在句子的开头，并提及一个或多个数字。五个大写字母形成打开保险箱的组合。通过以适当的方式组合来自所有数字的数字，您将获得一个数字目标。（构建目标号码的细节是分类的）要找到组合，您必须选择满足以下等式的五个字母v，w，x，y和z，其中每个字母由其在字母表中的顺序位置替换A = 1，B = 2，…，Z = 26）。这个组合就是vwxyz。如果有多个解决方案，那么这个组合就是词典上最大的那个（字典序最大）。

思路分析

本题属于试数题，典型做法就是DFS+回溯。

方法一： 由于本题数据量不大，也可以直接暴力法解决。将数组降序排列，利用五重循环，得到第一个满足题意的解即为字典序最大的解。

方法二： 利用DFS+回溯解决试数题，用到死胡同、岔路口思想和visit数组思想。

1. 死胡同： 本题是要求试出5个数，因而搜索到第5层之后便到达死胡同。
2. 岔路口： 在搜索的前5层中，对于每个数的选择与否可以理解为岔路口。
3. visit数组： 利用visit数组标记已被选择的数字，在下次搜索时跳过该数。递归之后要记得将visit标记还原 （回溯） 。

辨析

1. 要求字典序最大的解，是将数组降序排列还是升序排列？

如果得到第一组解之后便立即退出程序，则应当将数组降序排列，得到字典序最大的解；
如果得到第一组解之后继续执行程序，每次产生的新解将覆盖上一次的解，最终得到的解是最后一组解。因而应当将数组升序排列，得到字典序最大的解。

以本题为例：
暴力法中，如果在得到结果后return，则应当将数组降序排列；如果得到结果后继续执行，则应将数组升序排列。
DFS回溯中，因为采用的是递归结构，很难中途直接退出程序，因而往往都是执行到最后，得到的应该是最后一组解，因而应当将数组升序排列；但在本文所附代码中，在对结果进行更新的条件中加入了flag==0的限制条件，也就是说只允许得到的第一组解对结果数组进行更新，后面得到的所有解都无法更新存储，因而最终得到的依然是第一组解，故应将数组降序排列。

代码——方法一

// 可以用strcmp()函数来判断字符串的字典序排序
// 希望得到字典序最大的解 —— 从大到小排序，得到第一个解即返回 
//                         从小到大排序，一直遍历得到最后一个解返回

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
using namespace std;

int target;
char str[30];
char ans[10];
int flag = 0; // 判断是否存在解的标志

int change(char a)
{
    int t = a - 'A' + 1;
    return t;
}

bool judge(int a, int b, int c, int d, int e)
{
    if(a-b*b+c*c*c-d*d*d*d+e*e*e*e*e == target)
    {
        return true;
    }
    else 
    {
        return false;
    }
}

void code(int len)
{
    for(int a=0; a<len; a++)
    {
        for(int b=0; b<len; b++)
        {
            if(b == a)
            {
                continue;
            }
            for(int c=0; c<len; c++)
            {
                if(c==b || c==a)
                {
                    continue;
                }
                for(int d=0; d<len; d++)
                {
                    if(d==c || d==b || d==a)
                    {
                        continue;
                    }
                    for(int e=0; e<len; e++)
                    {
                        if(e==d || e==c || e==b || e==a)
                        {
                            continue;
                        }
                        if(judge(change(str[a]), change(str[b]), change(str[c]), change(str[d]), change(str[e])) == true)
                        {
                            flag = 1;
                            ans[0] = str[a];
                            ans[1] = str[b];
                            ans[2] = str[c];
                            ans[3] = str[d];
                            ans[4] = str[e];
                            return ; // 从大到小遍历，得到的第一个解便是字典序最大的解
                        }
                    }
                }
            }
        }
    }   
}

void print()
{
    if(flag == 0) 
    {
        printf("no solution\n");
    }
    else 
    {
        for(int i=0; i<5; i++)
        {
            printf("%c", ans[i]);
        }
        printf("\n");
    }
}

bool cmp(char a, char b)
{
    return a > b;
}

int main()
{   
    // freopen("input.txt","r",stdin);
    while(scanf("%d %s", &target, str)!=EOF)
    {
        flag = 0; // 每次判断前要把上次的标志恢复
        if(target==0 && strcmp(str,"END")==0)
        {
            break;
        }
        int len = strlen(str);
        // 当从小往大查询，查询的数依次增大，最终得到的结果必定是字典序号和最大的
        // 当从大往小查询，得到的第一个解则是字典序号和最大的
        sort(str, str+len, cmp); // 从大到小排序
        code(len);
        print();
    }
    // fclose(stdin);

    return 0;
}

代码——方法二

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
using namespace std;

int target;
char str[30];
char ans[10], temp[10];
int len;
int flag = 0; // 判断是否存在解的标志
int visit[30] = {0}; // 记录字符串每位被访问过与否 

int change(char a)
{
    int t = a - 'A' + 1;
    return t;
}

bool judge(int a, int b, int c, int d, int e)
{
    if(a-b*b+c*c*c-d*d*d*d+e*e*e*e*e == target)
    {
        return true;
    }
    else 
    {
        return false;
    }
}

// DFS搜索到最后得到的是最后一组解，前边的解都会被覆盖
void DFS(int depth)
{
    if(depth >= 5) // 死胡同——搜索5个数，深度从0~4，也就是说深度为5时开始判断本次搜索成功与否
    {   // 加flag==0则从大到小排序，不加flag==0则从小到大排序
        if(judge(change(temp[0]),change(temp[1]),change(temp[2]),change(temp[3]),change(temp[4]))==true && flag==0) // 存在解
        {                      // flag==0 得到第一组解后不再对解更新，第一组解是字典序最大，如果不加这个条件，则最后得到的是最后一组解       
            flag = 1;          
            strcpy(ans, temp); // 将正确的解存入ans，第一次存入的即为字典序最大           
        }
        return ; // 从大到小排序、搜索，得到的第一组解便是字典序最大的解
    }
    // 岔路口——按层次进行探索，探索完成进行回溯
    for(int i=0; i<len; i++)
    {
        if(visit[i] == 0) // 未访问过的字符
        {
            temp[depth] = str[i]; // temp临时记录路径
            visit[i] = 1; // 记录已被访问过
            DFS(depth+1); // 向下一层搜索
            visit[i] = 0; // 回溯，恢复该位置的访问记录
        }
    }
}

void print()
{
    if(flag == 0) 
    {
        printf("no solution\n");
    }
    else 
    {
        for(int i=0; i<5; i++)
        {
            printf("%c", ans[i]);
        }
        printf("\n");
    }
}

bool cmp(char a, char b)
{
    return a > b;
}

int main()
{
    // freopen("input.txt","r",stdin);
    while(scanf("%d %s", &target, str) != EOF)
    {
        flag = 0;
        if(target==0 && strcmp(str,"END")==0)
        {
            break;
        }
        len = strlen(str);
        sort(str, str+len, cmp); // 从大到小排序
        DFS(0); // 搜索
        print();
    }
    // fclose(stdin);

    return 0;
}