Java 从一个单词中删除一个字符的算法，这样减少的单词仍然是字典中的一个单词

下面是一个场景，给定一个单词，在每个步骤中从一个单词中删除一个字符，这样减少的单词仍然是字典中的一个单词。继续，直到没有字符

这里是一个陷阱： 您需要删除正确的字符，例如，在一个单词中，可能有两个可能的字符可以删除，这两个字符都可能导致缩减后的单词成为有效单词，但在稍后的阶段，其中一个可能会缩减到末尾，即没有剩余字符，而另一个可能会挂起

例如：

Set<String> dictionary = new HashSet<String>(Arrays.asList(
        "A", "AFRICA", "AN", "LANE", "PAN", "PANT", "PLANET", "PLANT"
));
WordMash mash = new WordMash(dictionary);

System.out.println(mash.mash("planet"));
System.out.println(mash.mash("pant"));


System.out.println(mash.mash("foo"));
System.out.println(mash.mash("lane"));
System.out.println(mash.mash("africa"));

• 行星
• 种植
• 喘息
• 平底锅
• 一个
• a

或

• 行星
• 飞机
• 小巷
• 如果lan不是一个词，那就不可能了。希望你有这个想法

请看我的代码，我使用递归，但想知道是否有更有效的解决方案来做同样的事情

public class isMashable
{

  static void initiate(String s)
  {
    mash("", s);
  }

  static void mash(String prefix, String s)
  {
    int N = s.length();
    String subs = "";

    if (!((s.trim()).equals("")))
      System.out.println(s);

    for (int i = 0 ; i < N ; i++)
    {
      subs = s.substring(0, i) + s.substring(i+1, N);
      if (subs.equals("abc")||subs.equals("bc")||subs.equals("c")||subs.equals("a")) // check in dictionary here
        mash("" + s.charAt(i), subs);
    }
  }

  public static void main(String[] args)
  {
    String s = "abc";
    initiate(s);
  }
}

公共类是可设置的
{
静态无效初始化（字符串s）
{
糖化物（“，s）；
}
静态void mash（字符串前缀，字符串s）
{
int N=s.长度（）；
字符串subs=“”；
如果（！（（s.trim（））.equals（“”））
系统输出打印项次；
对于（int i=0；i

运行BFS算法。

---

如果您有多个可以删除的字符，请逐个删除这些字符并将其放入优先级队列。如果要回溯路径，请在节点itslef中保留指向该单词父级（通过删除字符创建该单词的原始单词）的指针。当您删除所有字符、终止并回溯路径时，或者如果没有有效的方法，您将有一个空的优先级队列

好的，它不是Java，只是JavaScript，但您可能可以转换它：

函数子字（w，p，wrapL，wrapR）{
返回w.substr（0，p）
+（wrapL）（wrapL+w.substr（p，1）+wrapR）：“”）
+w.r（p+1）；
}
//wa=单词数组：['apple'，'banana']
//wo=单词对象/查找：{'apple'：true，'banana'：true}
函数initLookup（）{
window.wo={}；
对于（var i=0；i=0；li--）{
var水平=水平[li]；
对于（变量i=0；ibb.length）返回+1；
}
var len=数学最小值（aa.长度，bb.长度）
对于（变量i=0；ib）返回-1；
}
如果（aa.lengthbb.length）返回+1；
返回0；
}
函数prettyPrintTraces（行）{
var prevFirstWord=null；
对于（var ri=rows.length-1；ri>=0；ri--）{
var行=行[ri]；
if（prevFirstWord！=行[0]。word）{
if（prevFirstWord）$（'body'）。追加（“”）；
prevFirstWord=行[0]。word；
}
变量$row=$（''）；
对于（变量i=0；i

我已经在几个项目中使用过，这当然只会帮助你删去词尾

波特词干算法（或“波特词干分析器”）是 从单词中去除常见的词形和屈折词尾 用英语。其主要用途是作为术语规范化过程的一部分 这通常是在建立信息检索系统时完成的

一份重印本突然出现了

Martin甚至在他的网站上有一个标签。

用单词中的给定字符创建一个

trie

（或

后缀树

），并用字典检查trie的每个子树。这应该对你有帮助

参考访问

---

给你。mash方法将使用字典为任何给定字符串找到解决方案（字典单词列表）

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

public class WordMash {

    private final Set<String> dictionary;

    public WordMash(Set<String> dictionary) {
        if (dictionary == null) throw new IllegalArgumentException("dictionary == null");
        this.dictionary = dictionary;
    }

    public List<String> mash(String word) {
        return recursiveMash(new ArrayList<String>(), word.toUpperCase());
    }

    private List<String> recursiveMash(ArrayList<String> wordStack, String proposedWord) {
        if (!dictionary.contains(proposedWord)) {
            return null;
        }
        wordStack.add(proposedWord);

        if (proposedWord.length() == 1) {
            return wordStack;
        }

        for (int i = 0; i < proposedWord.length(); i++) {
            String nextProposedWord = 
                proposedWord.substring(0, i) + proposedWord.substring(i + 1, proposedWord.length());    
            List<String> finalStack = recursiveMash(wordStack, nextProposedWord);
            if (finalStack != null) return finalStack;
        }

        return null;
    }

}

Set<String> dictionary = new HashSet<String>(Arrays.asList(
        "A", "AFRICA", "AN", "LANE", "PAN", "PANT", "PLANET", "PLANT"
));
WordMash mash = new WordMash(dictionary);

System.out.println(mash.mash("planet"));
System.out.println(mash.mash("pant"));


System.out.println(mash.mash("foo"));
System.out.println(mash.mash("lane"));
System.out.println(mash.mash("africa"));

import java.util.HashSet;
import java.util.Set;

public class RemoveOneCharacter {
    static Set<String> dict = new HashSet<String>();

    public static boolean remove(String word){
        if(word.length() == 1)
            return true;

        if(!dict.contains(word))
            return false;

        for(int i=0;i<word.length();i++){
            String choppedWord = removeCharAt(word,i);
            boolean result = remove(choppedWord);
            if(result)
                return true;
        }
        return false;
    }

    public static String removeCharAt(String str, Integer n) {
        String f = str.substring(0, n);
        String b = str.substring(n+1, str.length());
        return f + b;
    }

    public static void main(String args[]){
        dict.add("heat");
        dict.add("eat");
        dict.add("at");
        dict.add("a");

        dict.add("planets");
        dict.add("planet");
        dict.add("plant");
        dict.add("plane");
        dict.add("lane");
        dict.add("plants");
        dict.add("pant");
        dict.add("pants");
        dict.add("ant");
        dict.add("ants");
        dict.add("an");


        dict.add("clean");
        dict.add("lean");
        dict.add("clan");
        dict.add("can");

        dict.add("why");

        String input = "heat";
        System.out.println("result(heat) " + remove(input));
        input = "planet";
        System.out.println("result(planet) " + remove(input));
        input = "planets";
        System.out.println("result(planets) " + remove(input));
        input = "clean";
        System.out.println("result(clean) " + remove(input));
        input = "why";
        System.out.println("result(why) " + remove(input));
        input = "name";
        System.out.println("result(name) " + remove(input));


    }

}