信息学奥赛一本通 1220：单词接龙 | 1913：【00NOIP普及组】单词接龙 | OpenJudge NOI 2.5 8783 | 洛谷 P1019 [NOIP2000 提高组] 单词接龙_1220:单词接龙

【题目链接】

ybt 1220：单词接龙
ybt 1913：【00NOIP普及组】单词接龙
OpenJudge NOI 2.5 8783:单词接龙
洛谷 P1019 [NOIP2000 提高组] 单词接龙

【题目考点】

1. 字符串处理，二维数组存储多个字符串
2. 深搜

【解题思路】

解法1：使用二维数组，构造接合点数组

（本解法有助于更细致地理解本题，但代码较长，思路理解后，可以转看解法2）
本题中“第几个”都是从0开始数的

1. 接合点概念

两个单词接合点为k的概念为：若两个单词可以接龙，接龙后第1个单词的第k位置和第二个单词的第0位置重合，那么称两单词的接合点为k。
若两单词不能接龙，接合点为0。

2. 最大接合点

两个单词可能会有多个接合点，由于本题要求的是最长的龙，两个单词接龙的重合部分越少，选择的接合点越大，最后得到的龙越长。因此本程序采用两个单词所有接合点中最大的接合点。

示例：
baa与aab接龙
可能的接龙为baab
baa
  aab
接合点为1
若接龙后为baaab
baa
    aab
接合点为2
这种情况的接合点的值更大，两单词的最大接合点为2

3. 相关数量关系

假设第一个单词长度为n1，第二个单词长度为n2，接合点为cp

1. 接合部分长度为n1-cp
2. 第二个单词接龙后使龙增加的长度为n2-n1+cp
3. 接合部分长度若大于等于第二个单词的长度，那么第一个单词包含了第二个单词，二者不再是接龙关系。所以有结合部分长度要小于第二个单词的长度，即n1 - cp < n2
4. 若接合点为0，则第二个单词包含了第一个单词，所以接合点要大于0，即cp > 0。（因此可以将不能接龙的情况设为cp = 0。）

4. 解题步骤

设二维数组cp，cp[i][j] 表示第i单词与第j单词的最大接合点。若i，j无法接龙，那么cp[i][j] = 0
设接龙数组lg, lg[i]表示龙中第i个单词的编号。

• 第一步，求出任意两个单词间的接合点，构造cp数组

• 第二步，在所有单词中找以初始字符开头的单词加入龙中，接下来不断搜索可以将哪些单词接在龙的后面。

• 搜索过程：
  遍历所有单词，找能与当前龙中最后一个单词接龙的单词。
  找的过程中判断单词使用次数不超过2。
  每有一个新的单词成功接龙，则尝试更新最大接龙长度，而后继续搜索。
  搜索后状态还原。

5. 所谓的“包含关系”

题中“相邻的两部分不能存在包含关系”这句实在含混不清，让我一开始误以为两个词不能存在包含关系。其实是说某个词和两词的重合部分不能有包含关系。

例：
baba与bab，虽然baba包含bab，但二者之间是可以接龙的，结果是babab， 接龙方法为
baba
    bab

因此自己和自己也是有可能接龙的，如：
bab与bab，接成babab
bab
    bab

解法2：使用string类，每次循环寻找重合部分

思路与上一种方法基本一致，用string类写语意更直接，更易理解。
由于每次循环都要寻找重合部分，相比于上一种解法中将接合点预先都算出来，复杂度要更高一些。不过本题数据量很小，这点增加的复杂度可以接受。
与上方法取“最大接合点”同样道理，两单词重合部分越少，得到的龙越长。所以重合部分长度从小向大遍历，只要找到一次有重合部分，就不再寻找。
具体请看注释。

【题解代码】

解法1：使用二维数组，构造接合点数组

#include<bits/stdc++.h>
using namespace std;
#define N 25
char word[N][N];//word[i]:第i个单词
int cp[N][N];//最大接合点数组，cp[i][j]表示第i单词与第j单词的最大接合点
int len[N];//len[i]:第i个单词的长度
int exist[N];//exist[i]:第i个单词已经在龙中出现几次
char sc;//初始字符
int n;//单词数量
int lgLen, mxLgLen;//lgLen:当前龙长度 mxLgLen:最大的龙长度
//获取单词s1和单词s2的接合点,n1,n2是字符串s1,s2的长度
int getCatchPoint(char s1[], int n1, char s2[], int n2)
{//p:第s1单词的下标，判断第p位置是不是接合点。从后向前遍历，第一个找到的接合点就是最大接合点。
    for(int p = n1 - 1; p > 0 && n1 - p < n2 ; p--)//p > 0见题解思路3.4, n1 - p < n2见题解思路3.3
    {
        if(s1[p] == s2[0])//有相同的字符，二者可能接龙
        {
            bool isOk = true;//能否接龙
            for(int i = p + 1, j = 1; i < n1; ++i, ++j)//i是s1的下标，j是s2的下标，从接合点后一个位置开始遍历。
            {//判断s1从s[p]末尾是否与s2前一段字符相同 
                if(s1[i] != s2[j])//遇到不同的字符，无法接龙
                {
                    isOk = false;
                    break;
                }
            }
            if(isOk)
                return p;//返回接合点
        }
    }
    return 0;//没找到接合点，两单词没有接龙，返回0
}
//初始化cp数组
void initCp()
{
    for(int i = 0; i < n; ++i)
        for(int j = 0; j < n; ++j)
            cp[i][j] = getCatchPoint(word[i], len[i], word[j], len[j]);//看word[i]和word[j]能否接龙，并寻找接合点。
 }
//向龙中添加单词
void addWordToLg(int lw)//lw:龙中最后一个单词的编号
{
    if(lgLen > mxLgLen)//取最大值。必须放在这里，不能放在下面循环内。否则只有1个单词时，无法取到最大值。
        mxLgLen = lgLen;
    for(int i = 0; i < n; ++i)//遍历各个单词，看第i单词能否添加到龙中
    {
        if(cp[lw][i] > 0 && exist[i] < 2)//如果龙中最后一个单词后面可以接第i单词 且 该单词没有在龙中出现2次
        {//将单词i接在后面 
            exist[i]++;//单词i出现次数增加1
            lgLen += len[i] - len[lw] + cp[lw][i];//增加的长度。见思路3.2
            addWordToLg(i);//尝试添加下一个单词
            exist[i]--;//还原状态
            lgLen -= len[i] - len[lw] + cp[lw][i];
        }
    }
}
int main()
{
    cin >> n;
    for(int i = 0; i < n; ++i)
    {
        cin >> word[i];
        len[i] = strlen(word[i]);
    }
    cin >> sc;//输入初始字符
    initCp();//初始化最大接合点数组
    for(int i = 0; i < n; ++i)
    {
        if(word[i][0] == sc)//如果第i单词首字母是sc
        {//把单词i加入龙 
            lgLen = len[i];
            exist[i]++;
            addWordToLg(i);//尝试把下一个单词加入龙
            exist[i]--;//还原
        }
    }
    cout << mxLgLen;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

解法2：使用string类，每次循环寻找重合部分

#include<bits/stdc++.h>
using namespace std;
#define N 25 
int n, totLen, mxLen;//totLen:龙当前长度 mxLen:龙最大长度 
string s[N];//s[i]:单词列表第i个单词 
int vis[N];//vis[i]:单词s[i]用了几次 
void dfs(string ls)//ls:当前龙中最后字符串 
{
    mxLen = max(totLen, mxLen);//取可能的最大的长度 
    for(int i = 1; i <= n; ++i)
    {
        if(vis[i] < 2)//只要用了不足2次 
        {
            int len;//ls与s[i]重合部分的长度 
            for(len = 1; len < ls.length() && len < s[i].length(); ++len)//由于重合部分不能包含单词，所以重合部分长度要小于两单词的长度 
            {//将ls末尾len个字符截取出来，看和s[i]前len个字符是否相同 
                if(ls.substr(ls.length()-len, len) == s[i].substr(0, len))//只要找到一个可以接上的情况，就不再找了，再找到的不会是最长的龙 
                    break;
            }
            if(len < ls.length() && len < s[i].length())//从上面循环中间跳出，表明s[i]可以接在ls后面。如果不满足该条件，说明循环运行到了最后，没有重合部分。 
            {
                vis[i]++;//s[i]多用了1次 
                totLen += s[i].length() - len;//总长度增加s[i].length() - len
                dfs(s[i]);
                totLen -= s[i].length() - len;//恢复状态 
                vis[i]--; 
            }
        }
    }
}
int main()
{
    char stch;//起始字符 
    cin >> n;
    for(int i = 1; i <= n; ++i)
        cin >> s[i];
    cin >> stch;
    for(int i = 1; i <= n; ++i)
    {
        if(s[i][0] == stch)//如果起始字符和s[i]首字符相同 
        {//以s[i]起始
            vis[i]++; 
            totLen = s[i].length();//当前总长度为s[i]的长度 
            dfs(s[i]);
            vis[i]--;//恢复状态 
        }
    }
    cout << mxLen;
    return 0;
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50