leetcode-139-Word Break

最新推荐文章于 2022-03-12 09:27:24 发布

原创最新推荐文章于 2022-03-12 09:27:24 发布 · 325 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #动态规划 #隔板问题

算法刷题专栏收录该内容

69 篇文章

订阅专栏

本文介绍了一种使用动态规划解决字符串拆分问题的方法，通过构建布尔数组来标记字符串中哪些部分可以由字典中的单词组成。文章详细解释了算法流程，并提供了完整的C++实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include <iostream>
#include <string.h>
#include <unordered_set>
using namespace std;
/*
深搜法：从头开始遍历一个分支，如果当前一个字符匹配了，就看下一个字符，仅当
全部字符匹配才返回true，每到一个分支的尽头，就检查从子树的起点到终点的字符串
是否在字典里，如果在字典里就可以更新子树的起点，重新进行判断；每次只集中寻找一个
token，找到了才继续往下找，但是当字符串很长的时候，每次都要扩展树到最大的深度
然后一个一个地判断，会超时。
 */
//class Solution {
//public:
//    bool wordBreak(string s, unordered_set<string> &dict) {
//        return dfs(s, dict, 0, 0);
//    }
//private:
//    static bool dfs(const string &s, unordered_set<string> &dict,
//                    size_t start, size_t cur) {
//        if (cur == s.size()) {
//            return dict.find(s.substr(start, cur-start+1)) != dict.end();
//        }
//        if (dfs(s, dict, start, cur+1)) return true;
//        if (dict.find(s.substr(start, cur-start+1)) != dict.end())
//            if (dfs(s, dict, cur+1, cur+1)) return true;
//        return false;
//    }
//};
/*
 动态规划：如果字符串s可以全部由字典的token组成，那么字符串s的某些特定的片段也可以
 由字典的token组成，那么片段的问题就是全局问题的子问题，只要找出所有子问题的解就能
 找到全问题的解。找出字符串的所有片段是一个隔板问题，字符串s的长度是l，那么隔板有l+1
 个，如果两个字符之间有一个隔板，说明隔板两边是两个片段，我们让只有是token的片段的右侧
 才能放隔板，这样从第一位开始到最后一位，如果最后一个字符的右侧也有隔板，说明整个字符串
 就是全部由token组成的，返回true。
 */
//class Solution {
//public:
//    bool wordBreak(string s, unordered_set<string> &dict) {
//        //bool partion[500];
//        bool *partion = new bool[s.length() + 1];
//        for (int i = 1; i < s.length() + 1; i++) {
//            partion[i] = false;
//        }
//        partion[0] = true;
//        int last = 0;
//        int current = -1;
//        while (last != current) {
//            last = current;
//            for (int i = current + 1; i <= s.length(); i++) {
//                if (partion[i] == true) {
//                    current = i;
//                    break;
//                }
//            }
//            int k = current;
//            for (int i = current + 1; i <= s.length(); i++) {
//                if (dict.find(s.substr(current, i - current)) != dict.end()) {
//                    k = i;
//                }
//            }
//            if (k != current) {
//                partion[k] = true;
//            }
//        }
//        return partion[s.length()];
//    }
//};
class Solution {
public:
    bool wordBreak(string s, unordered_set<string> &dict) {
        bool *partion = new bool[s.length() + 1];
        for (int i = 0; i < s.length() + 1; i++) {
            partion[i] = false;
        }
        //这要慎用啊，因为这句WA了
        //memset(partion, 0, sizeof(partion));
        partion[0] = true;
        int len = s.length();
        for (int i = 0; i < len + 1; i++) {
            for (int j = len; j > i; j--) {
                if (partion[i] == true && dict.find(s.substr(i, j - i)) != dict.end()) {
                    partion[j] = true;
                }
            }
        }
        return partion[s.length()];
    }
};
//"abcd"
//["a","abc","b","cd"]
//"acccbccb"
//["cc","bc","ac","ca"]
int main(int argc, const char * argv[]) {
    Solution s;
    unordered_set<string> us ({"cc","bc","ac","ca"});
    cout << s.wordBreak("acccbccb", us) << endl;
    return 0;
}