java实现字符串单词接龙

---

描述

单词接龙的规则是：
。可用于接龙的单词首字母必须要前一个单词的尾字母相同；
。当存在多个首字母相同的单词时，取长度最长的单词，如果长也相等，则取字典序最小的单词;已经參与接龙的单词不能重复使用；
。现给定一组全部由小写字母组成单词数组，并指定其中的一个单词作为起始单词，进行单词接龙；
。请输出最长的单词串，单词串是单词拼接而成，中间没有空。

输入描述：
。输入的第一行为一个非负整数，表示起始单词在数组中的索引K，0<=K<N;
。输入的第二行为一个非负整数，表示单词的个数N
。接下来的N行，分别表示单词数组中的单词。

备注:
。单词个数N的取值范围为[1，20]；
。单个单词的长度的取值范围为[1,30]。

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

用例：

输入：
0
6
word, dd, da, dc, dword, d

输出：
worddwordda

java实现（开箱即用）

package com.des.data.test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class WordChain {

    public static void main(String[] args) {
        int k = 4;
        int n = 6;
        String[] strs = {"word", "dd", "da", "dc", "dword", "d"};
        System.out.println(solution(0,strs));
    }

    public static String solution(int m, String[] strs) {
        StringBuffer stres = new StringBuffer();
        String startStr = strs[m];
        stres.append(startStr);
        char startc = startStr.charAt(startStr.length() - 1);
        List<String> strArr = Arrays.stream(strs).filter(p -> p != startStr).collect(Collectors.toList());
        for (int i = 0; i < strArr.size(); i++) {
            char finalStartc = startc;
            List<String> strsl = strArr.stream().filter(p -> p.charAt(0) == finalStartc).collect(Collectors.toList());
            if (strsl.isEmpty()) {
                break;
            }
            int len = 0;
            //找出长度最长的字符串
            for (int j = 0; j < strsl.size(); j++) {
                String strl = strsl.get(j);
                if (strl.length() > len) {
                    len = strl.length();
                }
            }
            int finalLen = len;
            List<String> strsll = strArr.stream().filter(p -> p.length() == finalLen).collect(Collectors.toList());
            String[] arrayN = strsll.toArray(new String[strsll.size()]);
            //冒泡
            for (int j = 0; j < arrayN.length; j++) {
                for (int k = 0; k < arrayN.length - j - 1; k++) {
                    if (arrayN[k].compareTo(arrayN[k + 1]) > 0) {
                        String tmp = arrayN[k];
                        arrayN[k] = arrayN[k + 1];
                        arrayN[k + 1] = tmp;
                    }
                }
            }
            String getStr = arrayN[0];
            stres.append(arrayN[0]);
            //循环一轮结束，初始化接龙开头字母 startc
            startc = getStr.charAt(getStr.length() - 1);
            //循环一轮结束，初始化strArr
            strArr = Arrays.stream(strs).filter(p -> p != getStr).collect(Collectors.toList());
            if (strArr.isEmpty()) {
                break;
            }
        }
        return stres.toString();
    }
}