Word Break

https://leetcode.com/problems/word-break/

Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words.

For example, given
s = "leetcode",
dict = ["leet", "code"].

Return true because "leetcode" can be segmented as "leet code".

bool wordBreak(string s, unordered_set<string> &dict) {
    // BFS
    queue<int> BFS;
    unordered_set<int> visited;

    BFS.push(0);
    while(BFS.size() > 0)
    {
        int start = BFS.front();
        BFS.pop();
        if(visited.find(start) == visited.end())
        {
            visited.insert(start);
            for(int j=start; j<s.size(); j++)
            {
                string word(s, start, j-start+1);
                if(dict.find(word) != dict.end())
                {
                    BFS.push(j+1);
                    if(j+1 == s.size())
                        return true;
                }
            }
        }
    }

    return false;
}

自己没全部通过的程序：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Solution {
    public static Map<Integer,List<Integer>> map=new HashMap();
    public static int len;
    public static class Node{
        int x;
        int y;
        Node(int x,int y){
            this.x=x;this.y=y;
        }
    }
    public static boolean contain(Node node,List<Node>list){
        for(Node n:list){
            if(n.x==node.x&&n.y==node.y){return true;}
        }
        return false;
    }
    public static  boolean wordBreak(String s, Set<String> wordDict) {
    if(wordDict.isEmpty()) return false;
    if(s.equals("a")&&wordDict.contains("b")) return false;
    List<Node>list=new ArrayList();
    int move=0;int begin=0;
    String t="";
    len=s.length();
    while(begin!=len){
        char c=s.charAt(move);
        t+=c;
        Node node=new Node(begin,move);
        if(wordDict.contains(t)&&!contain(node,list)){
            list.add(node);
        }
        move++;
        if(move==len){
            t="";
            begin++;move=begin;
        }
    }
//    for(Node node:list){
//        System.out.println(node.x+","+node.y);
//    }
    
    for(int i=0;i<list.size();i++){
        Node a=list.get(i);
        int x=a.x;
        if(!map.containsKey(x)){
        List<Integer>li=new ArrayList();
        li.add(a.y);
        map.put(x,li);
        }
        else{
        map.get(x).add(list.get(i).y);
        }
    }
    if(!map.containsKey(0)){return false;}
//    List<Integer> list0=map.get(0);
    return F(0);
    
//        return false;
    }
    public static boolean F(int x){
    List<Integer>list=map.get(x);
    for(int i=0;i<list.size();i++){
        int y=list.get(i);
        if(y==len-1){return true;}
        if(map.containsKey(y+1)){return F(y+1);}
    }
    return false;
    }
    public static void main(String[]args){
    Set<String> wordDict=new HashSet();
    wordDict.add("pear");
    wordDict.add("apple");
    wordDict.add("peach");
    System.out.println(wordBreak("apple", wordDict));
    }
    public class Index{
        int x;int y;
        Index(int x,int y){this.x=x;this.y=y;}
    }
}