LeeCode 30

最新推荐文章于 2024-09-27 11:26:03 发布

TINYST

最新推荐文章于 2024-09-27 11:26:03 发布

阅读量804

点赞数 7

文章标签： c++ 算法

本文链接：https://blog.csdn.net/m0_72688204/article/details/141904205

版权

LeeCode 30

题目：

思路：

朴素的想法，是创建一个 $m p$ 哈希表记录 $w or d s$ 中所有字符出现的次数，令 $n$ 为 $s . s i ze ()$ , $m$ 为 $w or d s . s i ze ()$ ， $l e n$ 为 $w or d s [0] . s i ze ()$ 。然后枚举 $s$ 中的每一个字符为一个子串的起点，创建第二个 $c n t H A S H$ ，再遍历子串中的单词，最后检查 $c n t$ 是否等于 $m p$ ，显然该算法的时间复杂度为 $O(n\times m\times len)$

根据题目给的数据范围，最坏约为 $10^{9}$ ，而LeetCode时间限制一秒，一般一秒处理 $10^{7}$ 左右，所以超时了

Code

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        int n = s.length(), m = words.size(), w = words[0].length();
        unordered_map<string, int> map;
        for (const string& word : words) {
            map[word]++;
        }
        vector<int> ans;
        for (int i = 0; i + m * w <= n; i++) {
            unordered_map<string, int> cur;
            string sub = s.substr(i, m * w);
            bool valid = true;
            for (int j = 0; j < sub.length(); j += w) {
                string item = sub.substr(j, w);
                if (map.find(item) == map.end()) {
                    valid = false;
                    break;
                }
                cur[item]++;
            }
            if (valid && cur == map) {
                ans.push_back(i);
            }
        }
        return ans;
    }
};

优化：

每个子串的起点是不可避免的需要枚举的，但是我们检查子串是否合法的的过程中，窗口每向前移动一次，我们就要遍历一次子串，与此同时我们发现，当前检查完的 $c n t$ 哈希表可以通过删除左侧的单词，添加右侧的的单词，得到窗口向前直接滑一个单词的长度后的 $c n t$ 的状态，所以我们把 $n\bmod len$ 将起点分为len类（只有 $\bmod len$ 才能遍历所有的合法的起点，因为每次要向前滑 $l e n$ ， $i+k\times len (0\leq i\leq len-1)$ 遍历每个与它相同余数的起点。

AcCode

class Solution
{
public:
    vector<int> findSubstring(string s, vector<string> &words)
    {
        unordered_map<string, int> mp;
        for (auto x : words)
        {
            mp[x]++;
        }
        vector<int> ans;
        int n = s.size();
        int m = words.size();
        int len = words[0].size();
        for (int i = 0; i < len; i++)
        {
            unordered_map<string, int> cnt;
            for (int j = i; j + len <= n; j += len)
            {
                // j,i为起始位置，len为单词长度
                string tmp = s.substr(j, len);
                cnt[tmp]++;
                // 当有一个完整的窗口时，滑动窗口，每次移动一个单词的长度
                if (j >= i + m * len)
                {
                    string tmp = s.substr(j - m * len, len);
                    // 删除最左边的单词,cnt[tmp]>=1,不会出现负数
                    cnt[tmp]--;
                    if (cnt[tmp] == 0)
                    {
                        cnt.erase(tmp);
                    }
                }
                //j是最后一个单词的第一个字符
                if (j >= i + (m - 1) * len)
                {
                    if (cnt == mp)
                    {
                        ans.push_back(j - (m - 1) * len);
                    }
                }
            }
        }
        return ans;
    }
};