力扣刷题-如何把时间超限代码改回正道？-用动态规划题力扣139 单词拆分来分享-c++实现

题目链接：单词拆分链接

• 最开始的代码，把三个小样例都过了

• 详细注释版代码如下：

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> mySet;
        mySet.insert(s);  // 初始化集合，将原始字符串 s 插入集合中，用于后续处理
        int len = wordDict.size(); // 获取字典中单词的总个数

        while (!mySet.empty()) {  // 当集合不为空时，继续处理
            // 每次从集合中取出第一个字符串
            auto it = mySet.begin();
            string temp = *it;  // 获取当前字符串
            char u = temp[0];  // 获取当前字符串的第一个字符
            int ll = temp.size();  // 获取当前字符串的长度

            // 遍历字典中的每一个单词
            for (string& st : wordDict) {
                int l = st.size();  // 获取字典中当前单词的长度
                if (ll < l) continue;  // 如果当前字符串长度小于字典单词长度，跳过

                // 如果当前字符串的第一个字符与字典单词的第一个字符相同
                if (u == st[0]) {
                    // 检查当前字符串的前缀是否与字典单词相等
                    if (temp.substr(0, l) == st) {
                        // 如果当前字符串完全匹配字典单词，且没有剩余部分，直接返回 true
                        if (ll == l)
                            return true;

                        // 如果当前字符串匹配了字典单词的前缀，但有剩余部分，将剩余部分加入集合继续处理
                        mySet.insert(temp.substr(l));
                    }
                }
            }

            // 使用迭代器直接移除集合中的当前字符串，这样做可以提高效率
            mySet.erase(it);
        }

        return false;  // 如果集合处理完毕仍未找到匹配，返回 false
    }
};

无奈提交的时候时间超限：

后来我进行如下几种优化时间的办法：

• 1.erase的时候直接写迭代器

auto it = mySet.begin();
string temp = *it;
mySet.erase(it);  // 通过迭代器删除

如果mySet.erase(temp);：

这是通过值 temp 来移除元素。该方式需要 unordered_set 再次查找 temp，以确定要移除的元素的位置，因此会稍微低效一些，因为它相当于进行了两次查找：一次是 mySet.find(temp)，然后再进行删除。

• 2.substr(0, i) 操作尽量减少，因为时间复杂度是O（n） 还是比较大的，我之前都是通过这个函数取子串，然后和dict里的内容匹配，所以用的比较多，于是有了下一点改进

• 3.字典使用 unordered_set 存储：

  • 通过将 wordDict 存储在 unordered_set 中，查找字符串是否在字典中的时间复杂度从 O(n) 降低到 O(1)。
  • 直接通过 unordered_set<string> dict(wordDict.begin(), wordDict.end()); 进行数据结构转换，实现查找的时间复杂度降低，避免遍历dict内容
  • 总结：需要大范围查找的vector，就转unordered_set！不仅省时间，还去重！

• 4.还有就是如果dict中有很多很小的子串，比如说a这种，在识别到了以后就乘胜追击，看是不是还能继续匹配：

  while (temp.substr(i, le) == prefix)
                          i += le;
  

• 其他题目的经验：能不用bool就不用bool，直接用int（时间效率会高很多），如果要返回bool的话，会自动转型成bool的

于是终于ac，时间内存都不错：

写好注释的代码如下：

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> mySet;
        mySet.insert(s);  // 将初始字符串 s 插入到集合 mySet 中，用于后续处理
        int len = wordDict.size(); // 获取字典中单词的总数
        unordered_set<string> dict(wordDict.begin(), wordDict.end());  // 将字典中的单词存储到一个无序集合 dict 中，以加速查找操作

        // 当集合 mySet 不为空时，继续处理
        while (!mySet.empty()) {
            // 从集合中取出第一个字符串
            auto it = mySet.begin();
            string temp = *it;  // 获取当前字符串
            int ll = temp.size();  // 获取当前字符串的长度

            // 遍历字符串的每一个前缀
            for (int i = 1; i <= ll; ++i) {
                string prefix = temp.substr(0, i); // 获取当前长度为 i 的前缀

                // 如果前缀存在于字典中
                if (dict.find(prefix) != dict.end()) {
                    int le = i;  // 记录前缀的长度
                    mySet.insert(temp.substr(i)); // 将剩余部分插入集合中

                    // 跳过连续重复的前缀部分
                    while (temp.substr(i, le) == prefix)
                        i += le;

                    // 如果 i 已经遍历完字符串的全部长度，说明匹配成功
                    if (i == ll) {
                        return true; // 完全匹配，返回 true
                    }

                    // 将剩余部分插入集合中，以便后续处理
                    mySet.insert(temp.substr(i));
                }
            }

            // 使用迭代器删除已处理的字符串，避免重复处理，提升效率
            mySet.erase(it);
        }

        // 如果所有可能性都处理完仍未找到可行的拆分，返回 false
        return false;
    }
};

• 之后我看了官方题解，和我是 不同的思路，写上注释供大家学习：

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        // 将字典中的所有单词插入到无序集合中，以便于高效查找
        auto wordDictSet = unordered_set<string>();
        for (auto word : wordDict) {
            wordDictSet.insert(word); // 插入每一个单词到无序集合中
        }

        // 动态规划数组 dp，dp[i] 表示 s 的前 i 个字符能否被拆分成字典中的单词
        auto dp = vector<bool>(s.size() + 1);
        dp[0] = true; // 空字符串是可以被拆分的，这是递推的起点

        // 开始动态规划，逐个增加字符串长度
        for (int i = 1; i <= s.size(); ++i) {
            for (int j = 0; j < i; ++j) {
                // 检查从 j 到 i 的子字符串是否在字典中
                if (dp[j] && wordDictSet.find(s.substr(j, i - j)) != wordDictSet.end()) {
                    dp[i] = true; // 如果找到匹配，标记 dp[i] 为 true
                    break; // 不需要继续检查其他 j，直接跳出内层循环
                }
            }
        }

        // 返回 dp[s.size()]，表示整个字符串 s 能否被拆分成字典中的单词
        return dp[s.size()];
    }
};