C++ STL在算法题中的常用语法/及其他常用库函数

multi_set

是一个有序容器，允许存储多个相同的元素，并且依然保持元素的有序性。

std::multiset<int> ms = {1, 2, 2, 3, 4, 5};

Vector

 1.将vector<int>中的元素全部置换为0

fill(vec.begin(), vec.end(), 0);

2.vector容器是可以直接用==比较是否值等的！

3.寻找vector<int>中的最小值（min_element返回的是迭代器，用*号解引用）

int min1 = *min_element(nums1.begin(), nums1.end());

Unordered_set/map

1. unordered_set的删除（count的值也会减少）

2.unordered_map中的int默认值是0，可以直接使用。

3.unordered_map的键值是否可哈希问题。

简单来说：

①合法且常见的

unordered_map<int, vector<string>>

②错，除非自定义哈希函数和相等比较函数

unordered_map<vector<string>, int>

4.枚举unordered_map中所有的元素写法：

for(auto& [k, v]: hash){
    cout << k << " " << v << endl;
}

5.unordered_set::insert返回值

• unordered_set::insert 返回一个 pair，其中 second 是一个布尔值，表示插入是否成功（true 表示插入成功，false 表示元素已存在）。

Leetcode 3396. 使数组元素互不相同所需的最少操作次数

问题相当于：

• nums 的最长无重复元素后缀。
• 

        若没有重复元素返回0。

class Solution {
public:
    int minimumOperations(vector<int>& nums) {
        unordered_set<int> seen;
        for (int i = nums.size() - 1; i >= 0; i --)
            if (!seen.insert(nums[i]).second)
                return i / 3 + 1;
        return 0;
    }
};

6.如何快速拿到一个int数组不同元素的个数。

已知数组：

vector<int>& nums

 统计办法：

unordered_set<int> st(nums.begin(), nums.end());

不同元素的个数就是st.size() 

Priority_queue

1.大根堆/小根堆的创建与记忆

priority_queue<int, vector<int>, greater<int>> heap; 

这行代码在 C++ 中声明了一个优先队列 heap，其元素类型为 int，使用 vector<int> 作为其底层容器，并且指定了 greater<int> 作为比较函数对象。

这里的关键是 greater<int> 的使用，它告诉 priority_queue 以相反于默认方式来比较元素。默认情况下，priority_queue 是一个最大堆（大根堆），即堆顶元素是最大的。但是，通过使用 greater<int>，它将变为最小堆（小根堆），即堆顶元素是最小的。

1. 默认情况：如果你不指定第三个模板参数，默认情况下 priority_queue 是一个最大堆。这是因为默认的比较是 less<int>，它将最大的元素放在堆顶。

2. 使用 greater：当你使用 greater<int> 作为第三个模板参数时，它改变了元素的比较方式，使得比较结果相反。因此，原本应该是最大的元素现在变成了最小的，堆变成了最小堆。

3. 记住关键字：less 通常意味着“较少”，在默认情况下它创建了一个最大堆。而 greater 意味着“更多”，使用它创建了一个最小堆

2.leetcode中若自定义比较函数为匿名函数，需要加上decltype来获取类型。

  

======API函数调用======

max使用

1.想一次性求出一系列的int或者其他类型的数字的最大值，需要先统一数据类型，再存放到临时的列表当中才行。

upper_bound和lower_bound

upper_bound使用示例（时间复杂度为O(log n)）

int main() {
    std::set<int> s = {1, 3, 5, 7, 9};
    // 查找大于 4 的第一个元素
    auto it = s.upper_bound(4);
    if (it != s.end()) 
        std::cout << "The first element greater than 4 is: " << *it << std::endl;
    else 
        std::cout << "No element found that is greater than 4." << std::endl;
    return 0;
}

lower_bound使用示例

int main() {
    std::set<int> s = {1, 3, 5, 7, 9};
    // 查找第一个大于或等于 5 的元素
    auto it = s.lower_bound(5);
    
    if (it != s.end()) 
        std::cout << "The first element greater than or equal to 5 is: " << *it << std::endl;
    else 
        std::cout << "No element found that is greater than or equal to 5." << std::endl;
    return 0;
}

使用情况/前提：

        upper_bound 是 C++ 标准模板库（STL）中的一个常用函数，特别是在有序容器（如 std::set 或 std::map/multi_set）中。upper_bound 返回一个迭代器，指向第一个大于指定值的元素。因此，upper_bound 通常用于在有序容器中查找某个范围的上界。

查找第一个小于给定值的元素 : 

        使用 lower_bound，找到第一个大于或等于给定值的元素，然后将迭代器向前移动一个位置来得到第一个小于给定值的元素

int main() {
    std::set<int> s = {1, 3, 5, 7, 9};
    int target = 6;
    // 找到第一个大于或等于 6 的元素
    auto it = s.lower_bound(target);

    // 如果它不是第一个元素，并且不等于 begin()，就向前移动迭代器
    if (it != s.begin()) {
        --it;  // 向前移动迭代器
        std::cout << "The first element less than " << target << " is: " << *it << std::endl;
    }
    return 0;
}

自定义排序/Lambda表达式

Leetcode 2545. 根据第 K 场考试的分数排序

class Solution {
public:
    vector<vector<int>> sortTheStudents(vector<vector<int>>& score, int k) {
        sort(score.begin(), score.end(), [&](const vector<int>& u, const vector<int>& v) {
            return u[k] > v[k];
        });
        return score;
    }
};

其他库函数

<format>和stoi（string to int）

class Solution {
public:
    string convertDateToBinary(string date) {
        return format("{:b}-{:b}-{:b}",
                      stoi(date.substr(0, 4)),
                      stoi(date.substr(5, 2)),
                      stoi(date.substr(8, 2)));
    }
};

自己手写：

class Solution {
public:
    string convertDateToBinary(string date) {
        auto convert2Num = [](string str) -> int{
            int res = 0;
            for (int i = 0; i < str.length(); i ++){
                res = res * 10 + str[i] - '0';
            } 
            return res;
        };
        auto convert2Bin = [](int num) -> string{
            string res = "";
            stack<int> st;
            while (num){
                st.push(num % 2);
                num = num / 2;
            }
            while (st.size()){
                int t = st.top();   st.pop();
                res += (t == 0) ? '0' : '1';
            }
            return res;
        };
            int y = convert2Num(date.substr(0, 4));
            int m = convert2Num(date.substr(5, 2));
            int d = convert2Num(date.substr(8, 2));
            return convert2Bin(y) + '-' + convert2Bin(m) + '-' + convert2Bin(d);
    }
};

ranges::min()

复杂度：O(n)