单词接龙

标题：单词接龙 | 时间限制：1秒 | 内存限制：262144K | 语言限制：

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

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int index = Integer.parseInt(in.nextLine());
        int size = Integer.parseInt(in.nextLine());
        List<String> list = new ArrayList<>();

        for (int i = 0; i < size; i++) {
            list.add(in.nextLine());
        }

        String start = list.remove(index);

        StringBuilder ans = new StringBuilder();
        ans.append(start);

        list.sort((o1, o2) -> {
            if(o1.length() != o2.length())
                return o2.length() - o1.length();
            else{
                return o1.compareTo(o2);
            }
        });


        boolean flag = true;
        while(flag){
            flag = false;
            char end = start.charAt(start.length() - 1);
            for (int i = 0; i < list.size(); i++) {
                if(end == list.get(i).charAt(0)){
                    start = list.remove(i);
                    ans.append(start);
                    flag = true;
                    break;
                }
            }
        }

        System.out.println(ans);

    }
}

#include <bits/stdc++.h>

#include <algorithm>
#include <cstring>
#include <utility>

#define MAXN 1234

using namespace std;

int k, n;
string a[MAXN];
string res;
bool vis[23];

void init() {
    k = 0;
    n = 0;
    res = "";
    memset(vis, false, sizeof(vis));
}

int main() {
    init();

    cin >> k >> n;
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }

    res += a[k];
    vis[k] = true;

    vector<string> fir;
    vector<string> max_len;
    int maxn = 0;
    for (;;) {
        fir.clear();
        max_len.clear();
        maxn = 0;
        char ori = res[res.size() - 1];

        // 首字母
        for (int i = 0; i < n; i++) {
            if (vis[i] == true) {
                continue;
            }
            if (a[i][0] == ori) {
                fir.push_back(a[i]);
            }
        }
        if (fir.empty()) {
            break;
        }
        // 最长
        for (int i = 0; i < (int)fir.size(); i++) {
            if (fir[i].size() > maxn) {
                maxn = fir[i].size();
                max_len.clear();
                max_len.push_back(fir[i]);
            } else if (fir[i].size() == maxn) {
                max_len.push_back(fir[i]);
            }
        }
        // 字典序
        sort(max_len.begin(), max_len.end());
        res += max_len[0];

        // 标记
        for (int i = 0; i < n; i++) {
            if (vis[i] == true) continue;
            if (a[i] == max_len[0]) {
                vis[i] = true;
                break;
            }
        }
    }
    cout << res << "\n";
    return 0;
}