leetcode-139-Word Break

#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;
//            }
//
4000
}
//        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;
}