lk_m1

1

对需要从数组提取从大到小的一组数据，然后对其操作（类似与比较）的思路，可以在逐渐寻找的过程中操作，这样最值也在不断被更新，而操作也在更新

class Solution {
public:
    vector<int> findIndices(vector<int>& nums, int indexDifference, int valueDifference) 
    {
        vector<int> a(2,-1);
        int min=0;
        int max=0;
        for(int i=0;i<nums.size()-indexDifference;i++)
        {
            int j=i+indexDifference;
            if(j>nums.size())
            {
                return a;
            }
            if(nums[i]>nums[max])
            {
                max=i;
            }
            if(abs(nums[max]-nums[j])>=valueDifference)
            {
                a[0]=max;
                a[1]=j;
                return a;
            }
            if(nums[i]<nums[min])
            {
                min=i;
            }
            if(abs(nums[j]-nums[min])>=valueDifference)
            {
                a[0]=min;
                a[1]=j;
                return a;
            }
        }
        return a;
    }
};

哈希集合到滑动窗口

哈希

哈希集合的优缺点
优点：

快速查找、插入和删除：哈希集合的这些操作的平均时间复杂度为O(1)。
避免重复：集合中的元素是唯一的，没有重复元素。
缺点：

不保证顺序：元素的顺序不一定是插入的顺序，遍历时顺序可能会变化。
额外空间：哈希集合需要额外的空间来存储哈希表，可能会比其他集合数据结构占用更多的内存。

#include <iostream>
#include <unordered_set>

int main() {
    std::unordered_set<int> hashSet;

    // 插入元素
    hashSet.insert(1);
    hashSet.insert(2);
    hashSet.insert(3);

    // 尝试插入重复元素
    if (!hashSet.insert(2).second) {
        std::cout << "2 is already in the set" << std::endl;
    }

    // 输出集合中的元素
    for (int element : hashSet) {
        std::cout << element << " ";
    }
    std::cout << std::endl;

    // 删除
    hashSet.erase(2);

    // 大小
    std::cout << "Size: " << hashSet.size() << std::endl;

    //查找
    if (hashSet.find(2) != hashSet.end()) {
        std::cout << "2 is in the set" << std::endl;
    }

    hashSet.find(2)用于查找2，若找到则返回对应的迭代器，没有则返回最后一位迭代器，最后一位插入的元素的下一位才是最后一位迭代器。

    return 0;
}

其中，std::unordered_set::insert会返回std::pair，包含了first和second。
first：指向新插入的元素或者是已经存在的具有等价键的元素的迭代器。
second：一个布尔值，如果插入了新的元素则为true，如果插入失败（因为元素已经存在）则为false。

此方法用于快速排除重复项

滑动窗口

这里仅以保留特殊的字符为例（最长不重复字符字串）

#include <iostream>
#include <unordered_set>

int test(string s) 
{
    std::unordered_set<int> hashSet;
    int left=0;
    int max=0;

    for(int i=0;i<s.length();i++)
    {
        while(hashSet.find(s[i])!=hashSet.end())
        {

            hashSet.erase(s[left]);
            //缩小窗口
            left++;
            //下限提高

        }
        max=max(max,i-left+1);
        //获得长度
        hashSet.inset(s[i]);

    }
}

哈希表

std::unordered_map<int, int> m;  
需要头文件#include <unordered_map>
以unordered_map<int,int> c为例
基本操作：
1.插入    c.insert(int);
2.查找    if(c.find(int)!==c.end());
3.删除    c.erase(int);

与哈希集合类似，可以以常数时间维护内部元素，能够存储元素及其索引。

零碎

使用 std::pair 或 std::tuple：
这是 C++ 标准库中提供的容器，可以将多个值打包在一起返回。

std::pair：用于返回两个值。
std::tuple：用于返回任意数量的值。
cpp
复制代码
#include <iostream>
#include <tuple>  // 包含 std::tuple 头文件
using namespace std;

pair<int, int> returnPair(int a, int b) {
    return {a + 1, b - 1};
}

tuple<int, double, string> returnTuple() {
    return {1, 3.14, "Hello"};
}

int main() {
    // 使用 pair
    auto [x, y] = returnPair(1, 10);
    cout << x << " " << y << endl;

    // 使用 tuple
    auto [a, b, c] = returnTuple();
    cout << a << " " << b << " " << c << endl;

    return 0;
}