12.单词拼接

---

一、问题

描述

• 单词接龙是一个与我们经常玩的成语接龙相类似的游戏，现在我们已知一组单词，且给定一个开头的字母，要求出以这个字母开头的最长的“龙”（每个单词都最多在“龙”中出现两次），在两个单词相连时，其重合部分合为一部分，没有重合部分则不能拼接，例如beast 和 astonish，如果接成一条龙则变为beastonish。

输入

• 输入的第一行为一个单独的整数 n表示单词数，以下 n 行每行有一个单词，输入的最后一行为一个单个字符，表示“龙”开头的字母。你可以假定以此字母开头的“龙”一定存在。
  1 ≤ n ≤ 12,每个单词长度不超过10

输出

• 只需输出以此字母开头的最长的“龙”的长度。
  -

二、解题步骤

1.难点

• 有多个龙头，选择哪一个
• 后面选择哪一个单词接龙
• 如何查找中间接壤匹配的部分

2.分析

• 利用DFS深度优先算法解决这个问题，只要能继续拼接，首先选择继续拼接，如果遇到限制条件则返回上一层，同时把used[]恢复为未访问，以便下一条路径可以重复访问这个点。
• 大概原理图示
  -

3.写代码

代码如下（示例）：

#include<iostream>
#include<cstring>
#include<cstdlib>
using namespace std;

// 每个单词的长度不超过10,而且单词数量也小于13
#define maxn 20

// 有递归操作，声明全局变量
// 存储输入的n个单词
string str[maxn];
// 和每一个单词对应，记录被使用的次数；
int used[maxn];


int maxlength=0;//记录最长的拼接长度

int n;//单词数量

int getcommon(string a,string b){
    int alength,blength;
    int minlength;
    
    alength = a.size();
    blength = b.size();
    minlength = min(alength,blength);
    int i,j;
    int flag;
    // 注意：字符串（数组)的最后一个下标是比他的size小1的，因为下标从0开始
    for(i=0;i<minlength;i++){
        flag =1;
        for(j=0;j<i+1;j++){
            // a从后往前取，b从前往后取，取的字符数量是从1个依次到minlength个
            // 匹配到之前不会都相等，当完全相等的时候也正是刚好匹配到的时候
            if(a[alength-i-1+j]!=b[j])
                flag=0;//只要有一个字符不等，flag取0
        }
        if(flag){
            // 依次取，当a的后i+1个值和b的前i+1个值完全相等时，返回i+1
            return i+1;
        }
    }
    // 没有相同的部分
    return 0;
}

void dfs(string head,int len){
    int i;
    int lencommon=0;// 共同部分的长度
    
    maxlength = max(maxlength,len);//选择一个更长的长度
    for(i=0;i<n;i++){   // 匹配每一个单词        
        if(used[i]>=2){
            //已经被使用两次了，跳过这个单词，选择下一个
            continue;
        }
        //跳过自己接自己的情况，这是没有意义的，还会增加操作，导致时间复杂度增加
        // if(head==str[i]){
        //     continue;
        // }
        // 遇到自己先跳过自己
        
        lencommon=getcommon(head,str[i]);
        if(lencommon>0){
            
            // 使用次数+1
            used[i]++;

            // dfs(str[i],maxlength+str[i].size()-lencommon);  //这样传递会使得maxlength是在记录走过的路径

            //!!!!每一层的len都是不一样的，返回上一层时也会使用上一层相应的len
            dfs(str[i],len+str[i].size()-lencommon);                      
            
            //回退的时候标记为未访问
            used[i]--;
        }
        
    }
    
}

int main(int argc, char*argv[]){
    
    int i;
    string s;  //龙头

    freopen("file in.txt","r",stdin);

    cin>>n;
    //判断n是否符合题意
    if(n<1||n>12)
        return 0;
    for(i=0;i<n;i++){
        cin>>str[i];
        //把每一个str[i]标记为未使用
        used[i]=0;
    }
    cin>>s;
    // 题目说龙头是一个单个字符
    dfs(s,1);
    cout<<maxlength<<endl;

    return 0;
}

4.易错分析

1. 程序遇到自己时也会进入 *getcommon（）*查找相同部分的长度，最后对maxlength没有帮助
   所以想遇到自己时跳过
   代码如下（示例）：

//跳过自己接自己的情况，这是没有意义的，还会增加操作，导致时间复杂度增加
        // if(head==str[i]){
        //     continue;
        // }
        // 遇到自己先跳过自己

/> 实际上这样跳过就会导致类似 “ata” 这样可以头尾相同的可以拼接的单词被跳过，导致maxlength比真实值要小

_ ！！！！所以是不能跳过的！！！！！_

2. maxlength不断叠加，变成了走过的所有路径
   代码如下（示例）：

// dfs(str[i],maxlength+str[i].size()-lencommon);  //这样传递会使得maxlength是在记录走过的路径

参数的传递要注意

5.改进

• 最后提交上取还是有一个案例报超过时间限制，应该每一个单词都要比较一下自己，这里如果可以先跳过就好了，但是改了半天总是拆东墙补西墙，这里对了，那里又错了
• 所以从别的基础操作来解决
• getcommon（）里面
  i从0开始，需要循环minlength次，如果从1开始，if里面不减1，对程序正确性没有影响，每次都减少了 1xj 次操作，估计这下时间限制可以pass了

！！！注意，i从 1 开始的话，龙头是单个字符，size为1，需要做一下处理，可以在前面加一个空格。

最终代码

代码如下：

#include <cstdlib>
#include <cstring>
#include <iostream>
using namespace std;

// 每个单词的长度不超过10,而且单词数量也小于13
#define maxn 20

// 有递归操作，声明全局变量
// 存储输入的n个单词
string str[maxn];
// 和每一个单词对应，记录被使用的次数；
int used[maxn];
int maxlength = 0;  //记录最长的拼接长度
int n;  //单词数量

int getcommon(string a, string b)
{
    int alength, blength;
    int minlength;

    alength = a.size();
    blength = b.size();
    minlength = min(alength, blength);
    int i, j;
    int flag;
    // 注意：字符串（数组)的最后一个下标是比他的size小1的，因为下标从0开始
    //从1个字母开始，递增取，进行对比，比如table和lemon，
    // 但是不能取到minlength，不然整个单词都被放进去了，对接龙的长度没有帮助
    for(i = 1; i < minlength; i++) {
        flag = 1;
        for(j = 0; j < i; j++) {
            // a从后往前取，b从前往后取，取的字符数量是从1个依次到minlength个
            // 匹配到之前不会都相等，当完全相等的时候也正是刚好匹配到的时候
            if(a[alength - i + j] != b[j]) {
                flag = 0;  //只要有一个字符不等，那么目前所取长度的部分是不相同的，flag取0
                break;  //可以跳出取更长长度的部分进行比较了
            }
        }
        if(flag) {
            // 如果flag为1，说明上面的循环没有发现不一样的，匹配上了，返回所取部分的长度
            return i;
        }
    }
    // 没有相同的部分
    return 0;
}

void dfs(string head, int len)
{
    int i;
    int lencommon = 0;  // 共同部分的长度

    maxlength = max(maxlength, len);  //选择一个更长的长度
    for(i = 0; i < n; i++) {  // 匹配每一个单词
        if(used[i] >= 2)  //已经被使用两次了，跳过这个单词，选择下一个
            continue;

        //跳过自己接自己的情况，这是没有意义的，还会增加操作，导致时间复杂度增加
        // if(head==str[i]){
        //     continue;
        // }
        // 遇到自己先跳过自己

        lencommon = getcommon(head, str[i]);
        if(lencommon > 0) {
            // 使用次数+1
            used[i]++;

            // dfs(str[i],maxlength+str[i].size()-lencommon);  //这样传递会使得maxlength是在记录走过的路径

            //!!!!每一层的len都是不一样的，返回上一层时也会使用上一层相应的len
            dfs(str[i], len + str[i].size() - lencommon);
            //回退的时候标记为未访问，回溯
            used[i]--;
        }
    }
}

int main(int argc, char* argv[])
{
    int i;
    string s;  //龙头

    freopen("file in.txt", "r", stdin);

    cin >> n;
    //判断n是否符合题意
    if(n < 1 || n > 12)
        return 0;
    for(i = 0; i < n; i++) {
        cin >> str[i];
        //把每一个str[i]标记为未使用
        used[i] = 0;
    }
    cin >> s;
    // 题目说龙头是一个单个字符
    dfs(' ' + s, 1);
    cout << maxlength << endl;

    return 0;
}

---

• file in.txt内容

5
at
touch
cheat
choose
tact
a