Leetcode - Word Break

最新推荐文章于 2025-12-03 08:43:36 发布

原创最新推荐文章于 2025-12-03 08:43:36 发布 · 115 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#大数据 #数据结构与算法

Dynamic Programming 专栏收录该内容

34 篇文章

订阅专栏

本文介绍了一种使用动态规划解决字符串分割问题的方法，通过三个步骤：确定历史信息及数据结构、推导递推关系式、设置初始条件来高效解决给定字符串是否可以被拆分为字典中词汇的问题。

[题目]

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

[分析] 摘自http://blog.youkuaiyun.com/linhuanmars/article/details/22358863

动态规划三步走法：首先，考虑解决问题过程中需要存储什么历史信息并采用何种数据结构合理；然后最关键的一步，推导递推关系式，即如何利用历史信息将问题推进解决，更具体地说如何获得当前状态；最后思考初始化条件。

[tips] 用StringBuilder只需要调用一次substring(), 因此version3实现耗时要远小于version1 & 2

public class Solution {
    // version 3
    // 历史信息：dp[i] 表示s.substring(0, i)能否用dict中的词汇表示
    // 递推式：dp[i] |= dp[j] & dict.contains(s.substring(j,i)), 其中0 <= j < i
    public boolean wordBreak(String s, Set<String> dict) {
        if (s == null || s.length() == 0)
            return false;
        int n = s.length();
        boolean[] dp = new boolean[n + 1];
        dp[0] = true;
        for (int i = 1; i <= n; i++) {
            StringBuilder sub = new StringBuilder(s.substring(0, i));
            for (int j = 0; j < i; j++) {
                if (dp[j] && dict.contains(sub.toString())) {
                    dp[i] = true;
                    break;
                }
                sub.deleteCharAt(0);
            }
        }
        return dp[n];
    }
}

public class Solution {
    // version 1： 二维数组保存历史信息
    public boolean wordBreak(String s, Set<String> dict) {
        //思路1：遍历dict，寻找能成为当前子串前缀的单词，递归判断剩余子串。大数据超时！
        //思路2：动态规划。回溯时有重复计算。f[i,j] |= f[i, k-1] && f[k, j] (i < k <= j), 
        if(s == null)
            return false;
        int n = s.length();
        boolean[][] dp = new boolean[n][n];
        for(int i = n - 1; i >= 0; i--){
            dp[i][i] = dict.contains(s.substring(i, i + 1));
            for(int j = i + 1; j < n; j++){
                dp[i][j] = dict.contains(s.substring(i, j + 1));
                if(dp[i][j])
                    continue;
                for(int k = i; k < n; k++){
                    dp[i][j] |= dp[i][k] && dp[k + 1][j];
                    if(dp[i][j])
                        break;
                }
            }
        }
        return dp[0][n-1];
    }
    
    // 一维数组
    public boolean wordBreak(String s, Set<String> dict) {
        //思路2：动态规划。回溯时有重复计算。dp[i] = dict.contains(s(i, k)) && dp[k] 
        if(s == null)
            return false;
        int n = s.length();
        boolean[] dp = new boolean[n + 1];
        dp[n] = true;
        for(int i = n - 1; i >= 0; i--){
            for(int k = i + 1; k <= n; k++){
                dp[i]= dict.contains(s.substring(i,k)) && dp[k];
                if(dp[i])
                    break;
            }
        }
        return dp[0];
    }
    
}