Lintcode--009(单词切分）

http://www.lintcode.com/zh-cn/problem/word-break/

单词切分

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

您在真实的面试中是否遇到过这个题？

 

样例

给出

s = "lintcode"

dict = ["lint","code"]

返回 true 因为"lintcode"可以被空格切分成"lint code"

标签：动态规划

解题：

还是动态规划问题， 动态规划的本质：根据已知结论推理未知结论。

思路： s = lintcode 可以分为 l和intcode，若是l是可分割单词，并且intcode单词在dict中，则表示s也是可分割单词。

若不符合，s = lintcode 可以分为 li和ntcode，若是li是可分割单词，并且ntcode单词在dict中，则表示s也是可分割单词。

...

同理得出BWord[ n ]表示字符串S[0,n]是否是可分割单词,是则为true，否为false。

BWord[ n ]  = BWord[ i ] &&( S[ i+1 ,n ]在dict中 )

 

java代码1：（有些超时）

    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()];  
      
        }  
    }  

java代码2：

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()];
    }

}

C++代码:

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==0&&dlen==0){ 
            return true; 
        } 
        if(slen==0||dlen==0){ 
            return false; 
        } 
        bool* dp=new bool[slen+1]; 
         
        dp[0]=true; 
        for(int i=0;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]; 
    } 
};

实验证明，C++ 运行时间更短，效率更高。

注：str.substr(startpos, length);

　　其中 startpos 是起始字符的序号，length 是[从 startpos 开始]取的字符串长度（包括startpos ）