牛客 HJ27 查找兄弟单词

描述
定义一个单词的兄弟单词为：交换该单词字母顺序（注：可以交换任意次），而不添加、删除、修改原有的字母就能生成的单词。
兄弟单词要求和原来的单词不同。例如： ab 和 ba 是兄弟单词。 ab 和 ab 则不是兄弟单词。
现在给定你 n 个单词，另外再给你一个单词 x ，让你寻找 x 的兄弟单词里，按字典序排列后的第 k 个单词是什么？
注意：字典中可能有重复单词。

数据范围：$1\le n\le 1000$ ，输入的字符串长度满足 $1\le len(str)\le 10$ ， $1\le k<n$

输入描述：
输入只有一行。 先输入字典中单词的个数n，再输入n个单词作为字典单词。 然后输入一个单词x 最后后输入一个整数k
输出描述：
第一行输出查找到x的兄弟单词的个数m 第二行输出查找到的按照字典顺序排序后的第k个兄弟单词，没有符合第k个的话则不用输出。

示例1

输入：
3 abc bca cab abc 1

输出：
2
bca
1
2
3
4
5
6

示例2

输入：
6 cab ad abcd cba abc bca abc 1
输出：
3
bca

说明：
abc的兄弟单词有cab cba bca，所以输出3
经字典序排列后，变为bca cab cba，所以第1个字典序兄弟单词为bca
1
2
3
4
5
6
7
8
9

java 实现

package nowcoder.x2x;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

public class HJ027 {
    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String s = null;
        List list = new ArrayList();
        while (null != (s = bf.readLine())) {
            int t1 = s.indexOf(" ");
            int t2 = s.lastIndexOf(" ");
			// 需要筛选单词的个数
            int num = Integer.parseInt(s.substring(0, t1));
            // 兄弟单词的索引
            int index = Integer.parseInt(s.substring(t2 + 1));

            s = s.substring(t1 + 1, t2);
            // 需要筛选单词数组
            String[] arr = s.split(" ");
            // 需要寻找兄弟单词的原单词
            String s1 = arr[arr.length - 1];
            // 原单词拆分成字符数组
            char[] char1 = s1.toCharArray();
            for (int i = 0; i < arr.length - 1; i++) {
                String temp = arr[i];
                // 相等、包含、长度不同，均不是兄弟单词
                if (s1.equals(temp) || temp.contains(s1) || temp.length() != char1.length) {
                    continue;
                }
                int sum = char1.length;
                int j = -1;
                for (char c : char1) {
                	// 遇到相同字符的处理
                    if (temp.indexOf(c) != -1 && temp.indexOf(c) != j) {
                        j = temp.indexOf(c);
                        sum -= 1;
                        temp = temp.replaceFirst(String.valueOf(c), " ");
                    }
                    // 原单词的所有字符已经遍历结束，但是temp中还有相同字符，则说明temp不满足兄弟单词的条件
                    if (sum == 0 && temp.indexOf(c) != -1) {
                        sum = -1;
                    }
                }
                // sum==0 代表此单词是兄弟单词
                if (sum == 0) {
                    list.add(arr[i]);
                }
            }
            System.out.println(list.size());
            Object[] e = list.toArray();
            Arrays.sort(e);
            // 输出第index个兄弟单词
            if (e.length >= index) {
                System.out.println(e[index - 1]);
            }
        }
    }
}

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