华为OD机试真题---单词接龙

原创已于 2024-11-15 20:13:41 修改 · 900 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#华为od #算法 #java #数据结构 #开发语言

于 2024-10-13 00:15:00 首次发布

算法同时被 2 个专栏收录

104 篇文章

订阅专栏

数据结构

100 篇文章

订阅专栏

问题描述：
单词接龙是一种有趣的文字游戏。在这个问题中，我们需要按照特定规则进行单词接龙，并找出最长的单词串。规则如下：

1、接龙的单词首字母必须与前一个单词的尾字母相同。
2、当有多个首字母相同的单词可选时，选择长度最长的单词。如果长度相同，则选择字典序最小的单词。
3、已经使用过的单词不能重复使用。
给定一组全部由小写字母组成的单词数组，以及指定的起始单词，请输出按照上述规则形成的最长单词串。单词串是由多个单词直接拼接而成，中间没有空格。

输入格式

输入包含多行：

第一行为一个非负整数 K，表示起始单词在数组中的索引，0≤K<N。
第二行为一个非负整数 N，表示单词的总数。
接下来的 N 行，每行包含一个单词，表示单词数组中的单词。

输出格式

输出一个字符串，表示最终拼接的最长单词串。

样例输入1

0
6
word
dd
da
dc
dword
d

样例输出1

worddwordda

样例输入2

4
6
word
dd
da
dc
dword
d

样例输出2

dwordda


import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Scanner;

public class WordChain {

    private static String longestChain = "";

    public static String longestWordChain(int K, int N, String[] words) {
        if (words == null || K < 0 || K >= N) {
            throw new IllegalArgumentException("Invalid input parameters");
        }
        Arrays.sort(words, Comparator.comparingInt(String::length).thenComparing(String::compareTo));
        boolean[] used = new boolean[N];
        // 确保K在有效范围内
        if (K >= words.length) {
            throw new IllegalArgumentException("Index K is out of bounds");
        }
        dfs(words, K, new StringBuilder(words[K]), used, 0);
        return longestChain;
    }

    private static void dfs(String[] words, int currentIndex, StringBuilder currentChain, boolean[] used, int chainLength) {
    // 增加对currentChain为空的处理
    if (currentChain.length() == 0) {
        dfs(words, currentIndex, currentChain, used, chainLength); // 直接递归，不添加字符
        return;
    }

    if (chainLength > longestChain.length()) {
        longestChain = currentChain.toString();
    }

    char lastChar = currentChain.charAt(currentChain.length() - 1);

    // 检查words是否为空或currentIndex是否越界
    if (words == null || words.length == 0 || currentIndex >= words.length) {
        return;
    }

    for (int i = currentIndex + 1; i < words.length; i++) {
        if (!used[i] && words[i].startsWith(String.valueOf(lastChar))) {
            used[i] = true;

            // 尝试减少StringBuilder对象的创建
            currentChain.append(words[i]); // 直接在当前链上追加
            dfs(words, i, currentChain, used, chainLength + words[i].length());

            // 回溯时重置状态
            currentChain.setLength(chainLength); // 恢复之前的长度
            used[i] = false;
        }
    }
}



    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int K = scanner.nextInt();
        int N = scanner.nextInt();
        scanner.nextLine(); // 读取换行符  

        String[] words = new String[N];
        for (int i = 0; i < N; i++) {
            words[i] = scanner.nextLine();
        }

        String result = longestWordChain(K, N, words);
        System.out.println(result);

        scanner.close();
    }
}