2024年C C++最全滑动窗口（二），一个APP从启动到主页面显示经历了哪些过程

最新推荐文章于 2024-10-17 17:21:13 发布

2401_84976104

最新推荐文章于 2024-10-17 17:21:13 发布

阅读量687

点赞数 13

分类专栏：程序员文章标签： c语言 c++ 学习

本文链接：https://blog.csdn.net/2401_84976104/article/details/138777424

版权

程序员专栏收录该内容

39 篇文章 0 订阅

订阅专栏

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

思路：使用哈希表对水果的种类进统计，利用滑动窗口算法来解决问题。

题目中给出的 “ fruits[i] 是第 i 棵树上的水果 **种类 ”**得意思是树上的水果种类是 0，1，2 这些，而不是树上有几种水果，一棵树上只能有一种水果！

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        unordered_map<int,int> hash;// 统计窗口中出现了哪些水果，并且他们出现的个数
        int ret = 0, left = 0, right = 0, n = fruits.size();
        while(right < n)
        {
            hash[fruits[right]]++;
            while(hash.size()>2)
            {
                hash[fruits[left]]--;
                if(hash[fruits[left]]==0) hash.erase(fruits[left]);
                left++;
            }
            ret = max(ret, right - left + 1);
            right ++;
        }
        return ret;
    }
};

由于题目中给出了数据范围，所以可以使用数组直接充当哈希表来提高效率！

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        //数据范围为 0 ~ 100000,可以用数组来模拟哈希表
        int hash[100001] = { 0 };
        int left = 0, right = 0, kinds = 0,n = fruits.size();// kinds用来维护哈希表里的水果种类
        int ret = 0;
        while(right < n)
        {
            if(hash[fruits[right]] == 0) kinds++;
            hash[fruits[right]]++;
            while(kinds > 2)
            {
                hash[fruits[left]]--;
                if(hash[fruits[left]] == 0) kinds--;
                left++;
            }
            right++;
            ret = max(ret,right - left);
        }
        return ret;
    }
};

找到字符串中所有字母异位词

给定两个字符串 s 和 p，找到 s中所有 p的 异位词的子串，返回这些子串的起始索引。不考虑答案输出的顺序。

异位词指由相同字母重排列形成的字符串（包括相同的字符串）。

思路：将 p 中的字符放入 hash2 ，利用滑动从窗口和哈希表在 s 中，当 hash1 等于 hash2 的时候，就是一个符合题目题目要求的条件，这时候就要更新结果，并使窗口继续滑动。

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        int n1 = s.size(), n2 = p.size();
        int left = 0, right = 0, len = n2;
        unordered_map<int, int> hash1,hash2;
        vector<int> v;
        while (len)
        {
            hash2[p[--len]]++;
            hash1[s[right++]]++;
        }
        while (right < n1)
        {
            while (right < n1 && hash1 == hash2)
            {
                v.push_back(left);
                hash1[s[right++]]++;
                hash1[s[left]]--;
                if (hash1[s[left]] == 0) hash1.erase(s[left]);
                left++;
            }
            if (right < n1)
            {
                hash1[s[right++]]++;
                hash1[s[left]]--;
                if (hash1[s[left]] == 0) hash1.erase(s[left]);
                left++;
            }              
        }
        if (hash1 == hash2) v.push_back(left);
        return v;
    }
};

串联所有单词的子串

给定一个字符串 s和一个字符串数组 words。 words 中所有字符串 长度相同。

s中的 串联子串 是指一个包含 words 中所有字符串以任意顺序排列连接起来的子串。

例如，如果 words = ["ab","cd","ef"]，那么 "abcdef"， "abefcd"，"cdabef"， "cdefab"，"efabcd"，和 "efcdab" 都是串联子串。 "acdbef" 不是串联子串，因为他不是任何 words 排列的连接。

返回所有串联子串在 s中的开始索引。你可以以 任意顺序 返回答案。

这道题目，是上一道题目的升级版，并且只能采用哈希表的容器来解决这道题目，相当于这道题是每次指针向前走 words 里的字符串长度个距离，然后在进行这个长度次循环，就能遍历出所有结果！

细节就是如果哈希表定义在外面，每进行一次循环就要清空一次哈希表！当然更好的情况是将哈希表直接定义在循环里。

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        vector<int> v1;
        unordered_map<string, int> hash1;
        unordered_map<string, int> hash2;
        //先将 vector 里的字符串放入哈希表
        int n = s.size(), len = words[0].size(), count = words.size();
        //先将 vector 里的字符串放入哈希表
        for (int i = 0; i < count; i++) hash2[words[i]]++;
        for (int i = 0; i < len; i++)
        {
            int left = i, right = i;
            while (right < n)
            {
                hash1[s.substr(right, len)]++; 
                if (hash1 == hash2)
                {
                    v1.push_back(left);
                }
                if (right - left >= (count - 1) * len)
                {
                    hash1[s.substr(left, len)]--;
                    if(hash1[s.substr(left,len)]==0) hash1.erase(s.substr(left, len));
                    left += len;
                }
                right += len;
            }
            hash1.clear();
        }
        return v1;
    }
};