Word Break

最新推荐文章于 2024-06-09 18:36:47 发布
最新推荐文章于 2024-06-09 18:36:47 发布
阅读量370 收藏
点赞数
分类专栏： lintcode-dynamic programming
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/poiop221/article/details/46119135
版权

中等 单词切分
11%
通过

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

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

给出

s = "lintcode"

dict = ["lint","code"]

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

标签  Expand 
字符串处理  动态规划 

public class Solution {
    /**
     * @param s: A string s
     * @param dict: A dictionary of words dict
     */
    public boolean wordSegmentation(String s, Set<String> dict) {
       if (s == null || s.length() == 0) {
            return true;
        }
        //找到dict 中最长单词的长度
        int maxLength = getMaxLength(dict);
        //
        boolean[] canSegment = new boolean[s.length() + 1];
        
        //最开始设为true, 符合s.length()==0的情况
        canSegment[0] = true;
        //遍历s里的每个单词
        for (int i = 1; i <= s.length(); i++) {
            canSegment[i] = false;
            //
            for (int j = 1; j <= maxLength && j <= i; j++) {
                //canSegement[i-j] == false， continue ==> j+1, 开始下一轮循环
                if (!canSegment[i - j]) {
                    continue;
                }
                /**
                 * substring(int beginIndex,int endIndex)
                 * 返回一个新字符串，它是此字符串的一个子字符串。
                 * 该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符。
                 * 因此，该子字符串的长度为 endIndex-beginIndex。
                 * "smiles".substring(1, 5) returns "mile"
                 * beginIndex - 起始索引（包括）。
                 * endIndex - 结束索引（不包括）。
                 */
                String word = s.substring(i - j, i);
                //如果dict包含word,canSegment[i]设为true,break
                if (dict.contains(word)) {
                    canSegment[i] = true;
                    break;
                }
            }
        }

        return canSegment[s.length()];
    }
    
    private int getMaxLength(Set<String> dict) {
        int maxLength = 0;
        for (String word : dict) {
            maxLength = Math.max(maxLength, word.length());
        }
        return maxLength;
    }
}


/**
         *    0 1 2 3 4 5 6 7 
         * s="l i n t c o d e" dict=["lint","code"]
         * s.length = 8, maxlength = 4;
         * i = 1, 
         *      canSegment[1] = false,
         *      j = 1, canSegment[0] = true,s.substring(0,1) ==> "l" ==> if;
         * i = 2,
         *      canSegment[2] = false,
         *      j = 1, canSegment[1] = false,continue;
         *      j = 2, canSegment[0] = true,s.substring(0,2) ==> "li" ==> if; 
         * i = 3,
         *      canSegment[3] = false,
         *      j = 1, canSegment[2] = false,continue;
         *      j = 2, canSegment[1] = false,continue;
         *      j = 3, canSegment[0] = true,s.substring(0,3) ==> "lin" ==> if; 
         *i = 4,
         *      canSegment[4] = false,
         *      j = 1, canSegment[3] = false,continue;
         *      j = 2, canSegment[2] = false,continue;
         *      j = 3, canSegment[1] = false,continue;
         *      j = 4, canSegment[0] = true, word = s.substring(0,4) ==> 
         *                    "lint" ==> if ==> canSegment[4] = true, break;
         * i = 5,
         *      canSegment[5] = false,
         *      j = 1, canSegment[4] = true,s.substring(4,5) ==>"c" ==> if;
         *      j = 2, canSegment[3] = false,continue;
         *      j = 3, canSegment[2] = false,continue;
         *      j = 4, canSegment[1] = false,continue;
         *      j = 5, canSegment[0] = true,s.substring(0,5) ==>"lintc" ==> if;
         *      
         * i = 6,
         *      canSegment[6] =false,
         *      j = 1, canSegment[5] = false,continue;
         *      j = 2, canSegment[4] = true,s.substring(4,6) ==>"co" ==> if;
         *      j = 3, canSegment[3] = false,continue;
         *      j = 4, canSegment[2] = false,continue;
         *      j = 5, canSegment[1] = false,continue;
         *      j = 6, canSegment[0] = true,s.substring(0,6) ==>"lintco" ==> if;
         * 
         * i = 7,
         *      canSegment[7] =false,
         *      j = 1, canSegment[6] = false,continue;
         *      j = 2, canSegment[5] = false,continue;
         *      j = 3, canSegment[4] = true,s.substring(4,7) ==>"cod" ==> if;
         *      j = 4, canSegment[3] = false,continue;
         *      j = 5, canSegment[2] = false,continue;
         *      j = 6, canSegment[1] = false,continue; 
         *      j = 7, canSegment[0] = true,s.substring(0,7) ==>"lintcod" ==> if; 
         * 
         * i = 8,
         *      canSegment[8] =false,
         *      j = 1, canSegment[7] = false,continue;
         *      j = 2, canSegment[6] = false,continue;
         *      j = 3, canSegment[5] = false,continue;
         *      j = 4, canSegment[4] = true,s.substring(4,8) ==>"code" ==> if
         *                                  ==> canSegment[8] = true, break;
         */



/**
         *    0 1 2 3 4 5 6 7 8 9 
         * s="l i n t c o d e l i" dict=["lint","code"]
         * s.length = 10, maxlength = 4;
         * i = 1, 
         *      canSegment[1] = false,
         *      j = 1, canSegment[0] = true,s.substring(0,1) ==> "l" ==> if;
         * i = 2,
         *      canSegment[2] = false,
         *      j = 1, canSegment[1] = false,continue;
         *      j = 2, canSegment[0] = true,s.substring(0,2) ==> "li" ==> if; 
         * i = 3,
         *      canSegment[3] = false,
         *      j = 1, canSegment[2] = false,continue;
         *      j = 2, canSegment[1] = false,continue;
         *      j = 3, canSegment[0] = true,s.substring(0,3) ==> "lin" ==> if; 
         *i = 4,
         *      canSegment[4] = false,
         *      j = 1, canSegment[3] = false,continue;
         *      j = 2, canSegment[2] = false,continue;
         *      j = 3, canSegment[1] = false,continue;
         *      j = 4, canSegment[0] = true, word = s.substring(0,4) ==> 
         *                    "lint" ==> if ==> canSegment[4] = true, break;
         * i = 5,
         *      canSegment[5] = false,
         *      j = 1, canSegment[4] = true,s.substring(4,5) ==>"c" ==> if;
         *      j = 2, canSegment[3] = false,continue;
         *      j = 3, canSegment[2] = false,continue;
         *      j = 4, canSegment[1] = false,continue;
         *      j = 5, canSegment[0] = true,s.substring(0,5) ==>"lintc" ==> if;
         *      
         * i = 6,
         *      canSegment[6] =false,
         *      j = 1, canSegment[5] = false,continue;
         *      j = 2, canSegment[4] = true,s.substring(4,6) ==>"co" ==> if;
         *      j = 3, canSegment[3] = false,continue;
         *      j = 4, canSegment[2] = false,continue;
         *      j = 5, canSegment[1] = false,continue;
         *      j = 6, canSegment[0] = true,s.substring(0,6) ==>"lintco" ==> if;
         * 
         * i = 7,
         *      canSegment[7] =false,
         *      j = 1, canSegment[6] = false,continue;
         *      j = 2, canSegment[5] = false,continue;
         *      j = 3, canSegment[4] = true,s.substring(4,7) ==>"cod" ==> if;
         *      j = 4, canSegment[3] = false,continue;
         *      j = 5, canSegment[2] = false,continue;
         *      j = 6, canSegment[1] = false,continue; 
         *      j = 7, canSegment[0] = true,s.substring(0,7) ==>"lintcod" ==> if; 
         * 
         * i = 8,
         *      canSegment[8] =false,
         *      j = 1, canSegment[7] = false,continue;
         *      j = 2, canSegment[6] = false,continue;
         *      j = 3, canSegment[5] = false,continue;
         *      j = 4, canSegment[4] = true,s.substring(4,8) ==>"code" ==> if
         *                                  ==> canSegment[8] = true, break;
         * i = 9,
         *      canSegment[9] =false,
         *      j = 1, canSegment[8] = true,s.substring(8,9) ==>"l" ==> if;
         *      j = 2, canSegment[7] = false,continue;
         *      j = 3, canSegment[6] = false,continue;
         *      j = 4, canSegment[5] = false,continue;
         *      j = 5, canSegment[4] = true,s.substring(4,9) ==>"codel" ==> if;
         *      j = 6, canSegment[3] = false,continue;
         *      j = 7, canSegment[2] = false,continue;
         *      j = 8, canSegment[1] = false,continue;
         *      j = 9, canSegment[0] = true,s.substring(0,9) ==>"lintcodel" ==> if;
         *
         * i = 10,
         *      canSegment[10] =false,
         *      j = 1, canSegment[9] = false,continue;
         *      j = 2, canSegment[8] = true,s.substring(8,10) ==>"li" ==> if;
         *      j = 3, canSegment[7] = false,continue;
         *      j = 4, canSegment[6] = false,continue;
         *      j = 5, canSegment[5] = false,continue;
         *      j = 6, canSegment[4] = true,s.substring(4,10) ==>"codeli" ==> if;
         *      j = 7, canSegment[3] = false,continue;
         *      j = 8, canSegment[2] = false,continue;
         *      j = 9, canSegment[1] = false,continue;
         *      j = 10, canSegment[0] = true,s.substring(0,10) ==>"lintcodeli" ==> if;
         *                                  
         */




poiop221
关注
专栏目录
html word-break,HTML Style wordBreak用法及代码示例
weixin_29282577的博客
06-30 1098
DOM样式wordBreak属性用于设置或返回word-break属性。 word-break属性用于指定在行尾到达单词时如何中断单词。文本中的换行符可以出现在特定的wordBreak属性中。用法:它用于返回wordbreak属性：object.style.wordBreak它用于设置wordBreak属性：object.style.wordBreak = "normal|break-all|ke...
Leetcode Word Break II
靖空间
03-04 5112
难度是5星级了。 主要的难点： 要优化到极致，不能直接使用递归回溯法，否则超时。 本程序是连打带消地对付了这种情况效率是十分高的了，有12ms运行时间的战果。 比网上很多博客的程序要优化，关键是动态规划表的构建功力，本程序的构建方法应该是最优的。有能改进的欢迎指教。 本程序方法：
Leetcode Word Break
靖空间
03-02 1899
使用动态规划法是很好解决的。 时间复杂度是O(n*n)。 形成这种思维需要不断锻炼，以前看这道题的时候觉得十分困难，现在终于觉得很容易的了。 评价为3到4星级吧。
lintcode:Word Break
知之可否
04-13 769
Given a string s and a dictionary of words dict, determine if s can be break into a space-separated sequence of one or more dictionary words.设res[i]表示s的前i个数字母能否分拆后在dict中找到。 则 如果，则res[i]=true;class So
leetCode: Word Break I & Word Break II
快乐de胖虎
03-20 5902
题目： 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 =
word-break:break-all和word-wrap:break-word的区别
qingdouxiaohua的博客
10-26 1919
word-break: break-all: 该属性用于强制文本在任意字符间进行换行，即在单词中间或者长单词的中间进行强制换行。而对于英文等拉丁语系的文本，则可能会导致不必要的单词截断，因此需要慎重使用。word-wrap: break-word: 该属性用于允许长单词在必要的情况下换行，而不是在单词中间进行强制换行。该属性适用于拉丁语系的文本，如英文、法语等。word-break: break-all和word-wrap: break-word都是CSS属性，用于控制文本内容在容器中的换行行为。
html5 break word,word-break属性怎么用
weixin_42114580的博客
06-17 416
word-break属性用于指定非CJK(中日韩)脚本的断行规则，规定了自动换行的处理方法。通过使用 word-break 属性，可以让浏览器实现在任意位置的换行。CSS3 word-break属性作用：word-break 属性规定自动换行的处理方法。提示：通过使用 word-break 属性，可以让浏览器实现在任意位置的换行。语法：word-break: normal|break-all|k...
【Leetcode】Word Break II
业精于勤，荒于嬉
07-05 989
题目链接：https://leetcode.com/problems/word-break-ii/ Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word.Return all such po
LeetCode.Word Break
Infinite Script
10-06 1864
试题请参见: 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
word-break:break-word
qq_46490956的博客
07-18 301
word-break:break-word
LintCode 582: Word Break II
01-06
Word Break II Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word. Return all such possible sentences. Example Example 1...
css 英文换行 css(word-wrap/break)使纯英文数字自动换行
12-13
为了解决这个问题，我们可以利用`word-wrap`和`word-break`两个CSS属性。 `word-wrap`属性主要用于控制是否允许内容在单词内部换行。它有两个主要的取值： 1. `normal`：这是默认值，遵循浏览器的默认换行规则。在...
DT_WORDBREAK、DT_PATH_ELLIPSIS和DT_WORD_ELLIPSIS的使用
最新发布
dvlinker的技术专栏
06-09 53
DT_WORDBREAK、DT_PATH_ELLIPSIS和DT_WORD_ELLIPSIS的使用
Leetcode 139. Word Break （python+cpp）
qq_37821701的博客
05-25 552
Leetcode 129 Word Break题目解法1：recursion (TLE)解法2：recursion + memorization解法3：动态规划 题目 解法1：recursion (TLE) 最直观的解法就是用recursion将string不断分成小的部分，但是这样的方法会超时，代码如下： class Solution: def wordBreak(self, s: str, wordDict: List[str]) -> bool: # recurrsio
leetcode题解：第139题Word Break
chenf1999的博客
08-07 385
https://leetcode-cn.com/problems/word-break/ 文章目录解法一、回溯代码解法二、动态规划代码复杂度分析 解法一、回溯 依照惯例，没有好的思路的时候，就先想想暴力解法怎么做。暴力解法无非是逐个单词地拆分字符串，每次选的单词可以重复。要实现暴力解法的话，肯定就是用回溯，因为回溯算法“撤销选择”的特点，保证了每次都能考虑到所有的单词。 简而言之，对于字符串s和单词word，word长度为n，当word与s[:n]相同时，就可以把word选来进行一次拆分，紧接着继续判断s[
unique-paths
poiop221的专栏
07-06 1084
容易 不同的路径 39% 通过 有一个机器人的位于一个M×N个网格左上角（下图中标记为'Start'）。 机器人每一时刻只能向下或者向右移动一步。机器人试图达到网格的右下角（下图中标记为'Finish'）。 问有多少条不同的路径？ 您在真实的面试中是否遇到过这个题？  Yes 样例 1,1 1,2
backpack ii
poiop221的专栏
06-01 767
中等 背包问题 II 查看运行结果  34% 通过 给出n个物品的体积A[i]和其价值V[i]，将他们装入一个大小为m的背包，最多能装入的总价值有多大？ 您在真实的面试中是否遇到过这个题？  Yes 样例 对于物品体积[2, 3, 5, 7]和对应的价值[1, 5, 2, 4], 假设背包大小为10的话，最大能够装入的
jump game
poiop221的专栏
05-26 443
中等 跳跃游戏 查看运行结果  40% 通过 给出一个非负整数数组，你最初定位在数组的第一个位置。　　　 数组中的每个元素代表你在那个位置可以跳跃的最大长度。　　　　 判断你是否能到达数组的最后一个位置。 您在真实的面试中是否遇到过这个题？  哪家公司问你的这个题？  感谢您的反馈 样例 A =
palindrome partition II
poiop221的专栏
05-28 438
Given a string s, partition s such that every substring of the partition is a palindrome. Return the minimum cuts needed for a palindrome partitioning of s. For example, given s = "aab", Return 1 sinc
ant -table customHeaderCell: () => { return { style: { wordWrap: "break-word", wordBreak: "break-all", whiteSpace: "normal", minHeight: "50px", width: "40px", }, }设置宽带无效;
06-12
这段代码中设置宽度无效的原因可能是其他样式或代码覆盖了宽度的设置。你可以尝试使用 !important 标记来强制设置宽度，例如：width: 40px !important; 或者检查其他相关的样式或代码是否影响了宽度的设置。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值