Word Break 判断是否能把字符串拆分为字典里的单词 @LeetCode

最新推荐文章于 2025-06-03 15:43:33 发布

原创最新推荐文章于 2025-06-03 15:43:33 发布 · 5.2k 阅读

2 ·

CC 4.0 BY-SA版权

Leetcode 同时被 2 个专栏收录

153 篇文章

订阅专栏

LeetCode专栏

148 篇文章

订阅专栏

本文探讨了如何解决LeetCode上的Word Break问题，最初尝试使用DFS导致超时，随后转向DP方法。作者提供了相关链接及重写后的清晰逻辑：若字符串s[0,i)可拆分，必存在j，使s[0,j)可拆分且s[j,i)在字典中。" 114154531,10542794,JAVA加密算法详解：数字签名与RSA、DSA实现,"['JAVA开发', '加密算法', 'RSA算法', '数字签名', '安全性']

思路：

1 DFS 但是TLE

2 DP 还需多练。。。

http://www.programcreek.com/2012/12/leetcode-solution-word-break/

http://xixiaogualu.blogspot.com/2013/10/leetcode-word-break.html

package Level5;

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

/**
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".

 *
 */
public class S147 {

	public static void main(String[] args) {
		Set<String> dict = new HashSet<String>();
		dict.add("aaa");
		dict.add("aaaa");
		String s = "aaaaaaa";
		System.out.println(wordBreak(s, dict));
		System.out.println(wordBreak2(s, dict));
	}

	// DP
	public static boolean wordBreak(String s, Set<String> dict) {
		// 如果canBreak[i]为true，则s[0...(i-1)]能被拆分
		boolean[] canBreak = new boolean[s.length()+10];
		canBreak[0] = true;		// 初始化
		
		for(int i=0; i<s.length(); i++){
			if(canBreak[i] == false){
				continue;
			}
			for(String dictS : dict){
				int len = dictS.length();
				int end = i + len;
				if(end > s.length()){
					continue;
				}
				if(s.substring(i, end).equals(dictS)){
					canBreak[end] = true;
				}
			}
		}
		return canBreak[s.length()];
	}
	
	// DFS TLE
	public static boolean wordBreak2(String s, Set<String> dict) {
		return dfs(s, dict, 0);
    }
	
	public static boolean dfs(String s, Set<String> dict, int start){
		if(start >= s.length()){
			return true;
		}
		
		for(String dictS : dict){
			int len = dictS.length();
			if(start+len<=s.length() && s.substring(start, start+len).equals(dictS)){
				if(dfs(s, dict, start+len)){
					return true;
				}
			}
		}
		
		return false;
	}
	
}

重写了一遍，逻辑更加清晰：

核心思想是：

如果一个字符串 s[0,i) 能被拆分，则一定能找到一个j使得：s[0,j) 能被拆分且 s[j,i) 在字典中

注意字符串区间是左闭右开！

public class Solution {
    public boolean wordBreak(String s, Set<String> dict) {
        if(s.length() == 0) {
            return false;
        }
        boolean[] canBreak = new boolean[s.length()+1]; // canBreak[i]: whether s[0,i) can be break
        canBreak[0] = true;     // base case
        
        for(int i=1; i<=s.length(); i++) {  // last case: s[0,s.length()) == s
            boolean flag = false;
            for(int j=0; j<i; j++) {    // j should be smaller than i to include at least character
                // s[0,i) can be break only when s[0,j) can be break AND s[j,i) is in the dict
                if(canBreak[j] && dict.contains(s.substring(j, i))) {
                    flag = true;
                    break;
                }
            }
            canBreak[i] = flag;
        }
        
        return canBreak[s.length()];
    }
}