Question

我目前正致力于建立一个单词阶梯，通过一次仅更改一个字母来从一个单词到另一个单词[＆amp;当然，仍然保持它是一个真实的词语。

我认为问题出在这个方法 - 通过使用广度优先搜索遍历树来查找两个单词之间的链接。我已经通过给出here给出的描述来实现算法，但是，测试中给出的解决方案并不是最优的。一个例子[显然可能会错过说话者，付款人＆amp;庄园]：

Discovery: link found, 6 words
layer
sayer
payer
mayer
mayor
manor
major

理想情况是：

Discovery: link found, 3 words
layer
mayer
mayor
major

我已尝试调试此代码，但由于涉及大量循环，因此尝试解决问题并不是一种非常可行的方法。

一些指示：

它生成图表[connectionLink（）]，节省时间。
此方法的类存储在Hashtable中的所有节点[图中的点]，其中键是单词＆amp;对象是这个词的对象。

节点存储它所连接的节点列表[通过不同的字符]，一个是否已被访问的布尔值＆amp;这个词本身就是一个字符串。

/*
 *  @return     String      Returning a String listing words traversed to the goal
 *  @param      fW          First word
 *  @param      sW          Second word
 */
public String discovery(String fW,String sW){
    String result="Discovery: no link found";
    StringBuffer links=new StringBuffer();
    int i=0;

    Queue<Node> queue=new LinkedList<Node>();               //  Breadth first search uses a queue
    queue.add(hash.get(fW));                                //  Root of the tree, tree generated on the fly

    while(!queue.isEmpty()){
        Node current=(Node)queue.poll();
        if(!current.getVisited()){      
            current.setVisited(true);                       //  Making sure it's only cycled once

            if(current.getWord().equals(sW)){               //  Goal state
                while(current.getParent()!=null){           //  Generating the list words traversed
                    i++;
                    links.insert(0,"\n"+current.getParent().getWord());
                    current=current.getParent();
                }
                result="Discovery: link found, "+i+" words"+links.toString()+"\n"+sW;
                System.out.println(result);
                break;
            }
            else{
                connectionLink(current.getWord());              //  Finding connections

                for(Node node:current.getConnections()){        //  Getting the connections of the Node
                    if(!node.getVisited()){                     //  If child Node isn't visited, add to queue
                        node.setParent(current);                //  Sets parent as Node just left
                        queue.add(node);                        //  Adding Node to queue
                        //  System.out.println("Discovery: adding "+node.getWord()+" to queue. Child of "+node.getParent().getWord());
                        //  System.out.println("Discovery: current queue - "+queue.toString());
                    }
                }
            }
        }
    }
    clearVisited();
    return result;
}

节点[有标准的吸气剂＆amp;设置也]：

public class Node{
    private String word;                    //  The data of the Node
    private Node parent;
    private LinkedList<Node> children;  //  Holds children
    private boolean visited=false;


    public Node(String word){
        this.word=word.toLowerCase();
        children=new LinkedList<Node>();
    }

    /*
     *  @param      other       Connecting to another Node - adding a child
     */
    public void connectTo(Node other){
        if(!(children.contains(other))&&!(this==other))     children.add(other);    
    }

}

生成连接的方法，其中wordDifference是一种检查单词在字母上不同的方法，根据该测试返回一个布尔值：

/*
 *  @param      fW          Finding the links of the inputted String
 */
public void connectionLink(String fW){
    //  dKS=discoveryKeys enum, dK=discoveryKey
    Enumeration<String> dKS=hash.keys();
    while(dKS.hasMoreElements()){               //  Loop checks the word against every other word
        String dK2=dKS.nextElement();
        if(wordDifference(hash.get(fW),hash.get(dK2))){
            (hash.get(fW)).connectTo(hash.get(dK2));
            //  System.out.println("Linking: "+hash.get(fW).getWord()+" & "+hash.get(dK2).getWord());
        }
    }
}

非常感谢任何帮助。这段代码实际上可能没有任何问题，问题可能在其他地方，但提前感谢。

主要的问题是，这并没有产生最佳的[最短路径]结果 - 它通过不必要的单词来实现目标[如示例]，我的广度优先搜索的实现有什么问题[因为那应该是最佳的]？

非最佳广度优先搜索实现

0 个答案: