Question

给定一个字符串，我想找到没有换位的所有变体，只有删除。例如，给定字符串：

helloo

变体列表如下（用空格分隔）。

helloo hello heloo helo

到目前为止，我的解决方案是遍历每个字符，然后如果当前字符与下一个字符匹配，则递归尝试原始和删除的字符版本，如下所示。

// takes String with at most two consecutive characters of any character, 
// and returns an Iterable of all possible variants (e.g. hheello -> heello, hhello, ...)
private static Iterable<String> findAllVariants(String word) {
    StringBuilder variant = new StringBuilder(word);
    Queue<String> q = new LinkedList<String>();
    findAllVariants(word, variant, 0, q);
    return q;
}

// helper method
private static void findAllVariants(String word, StringBuilder variant, int currIndex, Queue<String> q) {
    if (currIndex == variant.length() - 1) q.add(variant.toString());

    for (int i = currIndex; i < variant.length() - 1; i++) {
        char thisChar = variant.charAt(i);
        char nextChar = variant.charAt(i+1);
        if (thisChar == nextChar) {
            // get all variants with repeat character
            findAllVariants(word, variant, i+1, q);

            // get all variants without repeat character;
            variant = variant.deleteCharAt(i);
            findAllVariants(word, variant, i, q);
        }
    }
}

然而，我最终获得了大量的答案副本，而没有其他答案。当我在纸上进行算法时，似乎是正确的。我做错了什么？

Answer 1

以下代码中的某些内容将使您获得所有可能性（如果需要，请记住添加word本身）。我们的想法是检索删除一个字符的所有可能性（例如hello中的ello hllo helo hell结果。这些结果又可用于获取移除两个字符的可能性（再次移除一个字符）。导致llo elo ell ello等等......

List<String> getPossibilities(String word) {
    int removeChars = word.length() - 1;
    List<String> possibilities = new ArrayList();
    List<String> options = Arrays.asList(word);
    for(int i = 0; i <= removeChars; i++) {
        List<String> results = new ArrayList();
        for(String option : options) {
          for(String result : removeOneChar(option)) {
                if(!results.contains(result)) {
                    results.add(result);
                }
            }
        }
        possibilities.addAll(results);
        options = results;
    }
    return possibilities;
}

private static List<String> removeOneChar(String word) {
    List<String> results = new ArrayList();
    for(int i = 0; i < word.length(); i++) {
        int secondPart = i + 2;
        if(secondPart <= word.length()) {
            results.add(
                    word.substring(0, i) 
                    + word.substring(i + 1, word.length()));
        }
        else {
            results.add(
                    word.substring(0, i));
        }
    }
    return results;
}

注意if(!contains(result))以防止重复。

注意我已使用substring()来完成此操作，您使用removeCharAt()进行操作是另一个不错的选择。您可以运行一些测试，以确定哪个更好地决定使用哪个。使用后者的注意事项可能会消除if方法中private的需要。

Answer 2

我会使用相当不同的算法：我会找到所有重复（ll）（oo）（lll）（ooo）等...，保留一个数组描述它们在文本中的位置，以及每个字符的字符数重复。
例如，阵列A =
[升| 2]
的[o | 2]
。
。
点。

然后我会说第二个数组的初始计数为零，并在那里增加计数并打印出所有排列：

步骤4 :(再次增加第一个元素）
[l | 2] ==＆gt;不大于最大值，所以没有溢出，所以保持这种方式
的[o | 2]
==＆GT;打印helloo

查找字符串的变体（仅删除，无转置）

2 个答案: