Question

假设：

input字符串中的某些字符。
整数N

如何生成具有N个确切长度的所有可能单词？

如果我有input = {"a", "b", "a"}和N=2，那么输出应该是：ab,aa,ba（没有重复项）

我搜索了这个，我得到的是一些我无法理解的算法而不是实现。我知道我需要实现一个递归方法，但是在停止条件之后我就陷入了困境。

public void generate(String input, int length) {        
    if(length == 0) {
        System.out.println(input);
        return;
    }
    //Not sure about this part
    String[] a = input.split("");
    for(int i =0; i<a.length; i++) {
        loop(input+a[i], length-1);
    }
}

Answer 1

这应该可以解决问题并适用于任何input和N。 N = 0或N > input.length()

的行为定义不明确

public static void generate(String input, int N) {
    generate("", input, new HashSet<String>(), N);
}

private static void generate(String str, String input, Set<String> dup, int N) {
    if (str.length() == N && dup.add(str))
        System.out.println(str);
    else
        //remove a char form input and add it to str
        for (int i = 0; i < input.length(); i++)
            generate(
                str + input.charAt(i), 
                input.substring(0, i) + input.substring(i + 1), 
                dup, N);
}

这已经从更一般的“计算所有排列”问题进行了改编。在一般问题中，没有重复检查，str时会打印input.isEmpty()。如果您需要任何澄清，请告诉我。

Answer 2

这也适用于空字符串或n == 0。

重载是第二种重载combination()方法（采用四个参数的方法）。第一个重载只是将输入字符串转换为List<Character>并准备一个存储结果的空哈希集：

Set<String> combination(String input, int n) {
  List<Character> letters = new ArrayList<Character>();
  for (int i = 0; i < input.length(); ++i)
    letters.add(input.charAt(i));
  Set<String> results = new HashSet<String>();
  combination("", letters, n, results);
  return results;
}

void combination(String soFar, List<Character> letters, int n, 
    Set<String> results) {
  if (n == 0) { 
    results.add(soFar);
    return;
  }

  int startIndex = soFar.length();
  if (startIndex >= letters.size())
    return;      

  for (int i = startIndex; i < letters.size(); ++i) {
    // ch is the next candidate to add to the result that we're 
    // building (soFar)
    char ch = letters.get(i); 
    // Swap the characters at positions i and position startIndex.
    char temp = letters.get(startIndex);
    letters.set(i, temp);
    letters.set(startIndex, ch);

    // add ch to soFar, compute combinations of length n-1.
    // as startIndex is essentially soFar.length() this means that 
    // the recursive call will only process the remainder of the list.
    combination(soFar + ch, letters, n - 1, result);

    // Swap the characters back - restore the original state.
    letters.set(i, ch);
    letters.set(startIndex, temp);
  }

生成所有可能的长度为n的单词

2 个答案: