给出一个字符串s和一个词典，判断字符串s是否可以被空格切分成一个或多个出现在字典中的单词。

    public class Solution {

        /**

         * @param s: A string s

         * @param dict: A dictionary of words dict

         */

        public boolean wordBreak(String s, Set<String> dict) {

            // write your code here

             boolean BWord[] = new boolean[s.length()+1];

             BWord[0] = true;

             for(int i=1;i<s.length()+1;i++){

                  for(int j=i-1;j>=0;j--){

                       if(BWord[j]&&dict.contains(s.substring(j,i))){

                            BWord[i] = true;

                            break;

                       }

                  }

             }

             return BWord[s.length()];  

        }

    }  

public class Solution {

    /**

     * @param s: A string s

     * @param dict: A dictionary of words dict

     */

    public boolean wordBreak(String s, Set<String> dict) {

        // write your code here

        if((s==null ||s.length() ==0) && (dict == null || dict.size()==0))

            return true;

        return wordBreak(s,dict,0);

    }

     public boolean wordBreak(String s,Set<String> dict,int start){

        boolean dp[] = new boolean[s.length() + 1];

        dp[0] = true;//初始值

        for(int i = 0;i<s.length();i++){

            if(!dp[i])

                continue;

            for(String t:dict){

                int len = t.length();

                int end = i+ len;

                if(end > s.length())

                    continue;

                if(s.substring(i,end).equals(t)){

                    dp[end] = true;

                }

            }

        }

        return dp[s.length()];

    }

}

class Solution {

public:

    /**

     * @param s: A string s

     * @param dict: A dictionary of words dict

     */

    bool wordBreak(string s, unordered_set<string> &dict) {

        // write your code here

        //还是动态规划问题，先理解清楚题意；

        //将问题转化为小规模的问题，先看子问题是不是，然后在扩展；

        //程序思路很清楚； 

        int slen=s.size();

        int dlen=dict.size(); 

        if(slen==&&dlen==){

            return true;

        }

        if(slen==||dlen==){

            return false;

        }

        bool* dp=new bool[slen+]; 

        dp[]=true;

        for(int i=;i<slen;i++){

            if(!dp[i]){

                continue;//若dp[i]为false,则执行下一个i;

            }

            unordered_set<string>::iterator it;

            for(it=dict.begin();it!=dict.end();++it){

                string value=*it;

                int lv=value.size();//求出字典中字符串的长度；

                if(i+lv>slen){

                    continue;//如果长度大于s，则执行字典中的下一个字符串；

                }

                string last=s.substr(i,lv); //以i为初始地址，偏移量为lv

                if(last==value){

                    dp[i+lv]=true;

                }

            } 

        }

        return dp[slen];

    }

};