bitset 使用方法介绍： http://tumao.vip/p/4035/solution/68d35506ce5ce7e2d09fb481

map 和 make_pair使用方式：

#include <bits/stdc++.h>
using namespace std;
int main() {
    map<string, int> mapp;
    mapp["qian"] = 1;
    mapp["zhang"] = 2;
    cout << mapp["qian"] << " " << mapp["zhang"] << endl;

    mapp.insert({"zhang", 0});  //插入的key已存在，则不会改变
    cout << mapp["qian"] << " " << mapp["zhang"] << endl;

    mapp.insert({"wang", 3});
    mapp.insert({"xu", 4});
    mapp.emplace("chen", 5);
    mapp.insert(make_pair("teacher", 22));
    //如下是循环输出的代码, 默认按照key的字典序
    for (const auto& pair : mapp) {
        cout << pair.first << " " << pair.second << "  ";
    }
    cout << "\n";

    //----find()函数
    auto it = mapp.find("qian");
    if (it != mapp.end()) {
        // 如果找到了，输出键和值
        cout << "Found: " << it->first << " => " << it->second << endl;
    } else {
        // 如果没找到，输出相应信息
        cout << "Key not found." << endl;
    }

    mapp.insert({"xu", 6});
    //-----count()函数
    size_t num = mapp.count("xu");
    cout << num << endl;
    mapp["xu"] = 6;  // 直接更新键 "xu" 的值为 6
    for (const auto& pair : mapp) {
        cout << pair.first << " " << pair.second << "  ";
    }
    cout << "\n";

    // lower_bound() 函数，查找第一个不小于key的迭代器
    auto it_low = mapp.lower_bound("right");
    if (it_low != mapp.end()) {
        // 如果找到了，输出键和值
        cout << "Found: " << it_low->first << " => " << it_low->second << endl;
    } else {
        // 如果没找到，输出相应信息
        cout << "Key not found." << endl;
    }

    // upper_bound() 函数，查找大于key的迭代器
    auto it_upper = mapp.upper_bound("wang");
    if (it_upper != mapp.end()) {
        // 如果找到了，输出键和值
        cout << "Found: " << it_upper->first << " => " << it_upper->second
             << endl;
    } else {
        // 如果没找到，输出相应信息
        cout << "Key not found." << endl;
    }

    auto range = mapp.equal_range("wang");
    if (range.first != range.second) {
        cout << "Found: " << range.first->first << " => " << range.first->second
             << endl;
    } else {
        cout << "No element found for 'wang'." << endl;
    }
    //-- erase() 函数，用来删除对应的key和value
    mapp.erase("zhang");
    for (const auto& pair : mapp) {
        cout << pair.first << " " << pair.second << "  ";
    }
    cout << "\n";

     auto itt = mapp.find("qian");
     mapp.erase(itt); //参数可以为迭代器
     for (const auto& pair : mapp) {
        cout << pair.first << " " << pair.second << "  ";
    }
    cout<<"\n";
    //size()函数
    size_t size = mapp.size();
    cout<<size<<endl;
    //empty()函数
    bool is_empty = mapp.empty();
    cout<<is_empty<<endl;
    
    // 使用begin()和end()遍历map
    for (auto ittt = mapp.begin(); ittt != mapp.end(); ittt++) {
        std::cout << ittt->first << "   " << ittt->second <<"  ";
    }
    cout<<endl;
    mapp.clear();
    bool empty = mapp.empty();
    cout<<empty<<endl;
    cout << "\n";
    return 0;
}

优先队列priority_queue ： 使用方式：

#include <bits/stdc++.h>
using namespace std;
int main() {
    // 优先队列，默认是最大堆
    priority_queue<int> pq;

    // 添加元素
    pq.push(10);
    pq.push(20);
    pq.push(15);
    pq.push(5);
    // 依次移除元素
    cout << "Priority Queue elements:" << endl;
    while (!pq.empty()) {
        cout << pq.top() << endl;  // 打印最高优先级的元素
        pq.pop();                 // 移除元素
    }
    return 0;
}

优先队列的行为细节

1. ​优先级决定出队顺序​：
   • 优先队列中，元素的出队顺序完全由它们的优先级决定。这意味着具有最高优先级的元素总是最先被移除，而不考虑它们进入队列的顺序。
2. ​处理优先级相同的元素​​：
   • 当多个元素具有相同的优先级时，大多数实现的优先队列（如 C++ 的 std::priority_queue）并不保证这些元素的具体出队顺序。换言之，如果两个元素的优先级相同，哪个元素先被移除取决于底层堆的状态和元素在堆中的位置，而不是它们进入队列的顺序

与普通队列的比较

• ​普通队列​：
  • 遵循严格的先进先出原则。先进队的元素无论优先级如何，都会先出队。
  • 适用于确保按照严格的到达顺序处理元素的场景，如打印作业管理或银行客户排队。
• ​优先队列​：
  • 仅由元素的优先级决定出队顺序。最高优先级的元素总是最先出队，与元素的进队顺序无关。
  • 适用于需要基于优先级处理任务的场景，如操作系统的任务调度、网络路由中的数据包调度，或者任何需要快速访问最重要元素的场合。

因此，如果你的应用场景需要考虑进队顺序作为元素之间的次级排序依据，你可能需要自定义优先队列的行为，或者使用其他数据结构来维护进队顺序和优先级的关系

在 C++ 中的 priority_queue，优先级通常是根据元素的自然顺序定义的，这基于元素类型的比较方法来决定。默认情况下，优先队列使用元素类型的 operator< 来构建一个最大堆，这意味着最大的元素总被视为优先级最高的。如果你想改变优先级的定义，比如从最大堆改为最小堆或者定义自己的优先级规则，你可以通过提供一个自定义比较函数来实现。

自然顺序

默认情况下，priority_queue 使用元素的 < 操作符来比较元素，从而维护一个最大堆结构。例如，如果你有一个 priority_queue<int>，那么较大的数字会被赋予更高的优先级，因为 int 类型的 < 操作符定义了自然的数值比较。

自定义优先级

你可以通过提供自定义的比较函数来改变优先队列的行为，这可以通过两种方式实现：

1. ​**使用函数对象（Functor）**​：你可以定义一个类，实现 operator() 来指定比较逻辑。这允许你定义复杂的比较逻辑，不仅仅是简单的数据值比较。
2. ​使用 lambda 表达式​：在 C++11 及之后的版本中，你可以使用 lambda 表达式来提供比较函数，使代码更加简洁

示例：定义一个最小堆

以下是一个使用 priority_queue 创建最小堆的示例，其中使用了自定义的比较器：

#include <bits/stdc++.h>
using namespace std;
int main() {
    // 使用 greater<int> 来定义优先级，这会创建一个最小堆
    priority_queue<int, vector<int>, greater<int>> minHeap;
    // 添加元素到优先队列
    minHeap.push(10);
    minHeap.push(5);
    minHeap.push(15);

    cout << "队列按照从小到大顺序出队列:";
    while (!minHeap.empty()) {
        cout << ' ' << minHeap.top(); // 将会按照最小值到最大值的顺序打印
        minHeap.pop();
    }
    cout << '\n';
    return 0;
}

在这个例子中，greater<int> 是标准库中的一个比较类，它使得较小的元素被视为优先级更高，从而实现了最小堆的效果。你也可以定义自己的比较函数来实现更特定的优先级逻辑，例如基于对象的属性或者更复杂的规则

###如下自定义 优先级 代码解释

1. ​Person 结构体​：定义了一个包含姓名和年龄的简单结构。
2. ​ComparePerson 函数对象​：这是一个比较器，用于定义 priority_queue 的排序准则。在这个例子中，operator() 被定义为使得年龄较小的人物优先级更高。
3. ​优先队列的创建​：我们使用 priority_queue 模板并提供三个参数：元素类型 Person、底层容器 vector<Person> 和比较器 ComparePerson。这样设置后，队列将根据年龄从小到大的顺序优先出队。
4. ​添加和移除元素​​：元素被添加到队列中，并根据定义的比较规则排序。当我们访问和移除队列顶部元素时，总是获取到当前年龄最小的人物

#include <bits/stdc++.h>
using namespace std;
// 定义一个结构体来表示人物
struct Person {
    string name;
    int age;
    Person(string n, int a) : name(n), age(a) {}
};
// 自定义比较函数对象
struct ComparePerson {
    bool operator()(const Person& p1, const Person& p2) {
        // 使得年龄小的人物优先级更高
        return p1.age > p2.age;
    }
};
int main() {
    // 创建一个优先队列，其中元素是Person结构，使用自定义的比较函数
    priority_queue<Person, vector<Person>, ComparePerson> pq;
    // 添加几个人物到优先队列
    pq.push(Person("Alice", 30));
    pq.push(Person("Bob", 25));
    pq.push(Person("Charlie", 35));
    // 输出优先队列中的元素
    cout << "按照年龄小的任务优先级更高的顺序出队:" << endl;
    while (!pq.empty()) {
        Person p = pq.top();
        cout << p.name << " (" << p.age << ")" << endl;
        pq.pop();
    }
    return 0;
}

队列 queue的基本使用方法：

基本操作

队列支持几种基本操作，包括：

• ​push​：在队列的末尾添加一个元素。
• ​pop​：移除队列的第一个元素。
• ​front​：访问队列的第一个元素。
• ​back​：访问队列的最后一个元素。
• ​empty​：检查队列是否为空。
• ​size​：返回队列中的元素个数。

#include <bits/stdc++.h>
using namespace std;
int main() {
    queue<int> q;
    // 向队列添加元素
    q.push(10);
    q.push(20);
    q.push(30);
    cout << "Front element: " << q.front() << endl; // 输出 10
    cout << "Back element: " << q.back() << endl;   // 输出 30
    // 移除队列元素
    q.pop();
    cout << "New front element: " << q.front() << endl; // 输出 20
while(!q.empty()){
    	cout<<q.front()<<" ";
    	q.pop();
	}
    return 0;
}

底层实现

queue 是一个容器适配器，它给予用户一种方式，可以只在一端增加元素，而在另一端删除元素。在 C++ 中，默认情况下，queue 使用 deque 作为其底层容器，但也可以指定使用其他类型的容器，如 list。

自定义底层容器

可以在定义 queue 时指定底层容器，例如使用 list 作为底层容器：

#include <bits/stdc++.h>
using namespace std;
queue<int, list<int>> myQueue;

选择不同的底层容器会影响队列操作的性能，因此应根据具体需求来选择最合适的容器类型

银行柜台服务模拟

程序演示顾客排队等待服务的过程，每个顾客在队列中等待服务，然后从队列中移除表示他们的服务已完成

#include <bits/stdc++.h>
using namespace std;
int main() {
    queue<string> bankQueue;  // 创建一个队列存储顾客姓名
    // 顾客按顺序到达并排队
    bankQueue.push("Alice");
    bankQueue.push("Bob");
    bankQueue.push("Charlie");
    bankQueue.push("Diana");

    cout << "There are currently " << bankQueue.size() << " people in the queue.\n";

    // 开始服务队列中的顾客
    while (!bankQueue.empty()) {
        // 访问队首的顾客（即将得到服务的顾客）
        string currentCustomer = bankQueue.front();
        cout << currentCustomer << " is being served." << endl;
        // 服务完成后，将该顾客从队列中移除
        bankQueue.pop();
        // 显示剩余顾客数量
        cout << "There are now " << bankQueue.size() << " people in the queue.\n";
    }
    cout << "All customers have been served!" << endl;
    return 0;
}

代码解释

1. ​初始化队列​：创建一个类型为 string 的 queue 来存储顾客的名字。
2. ​顾客到达​：使用 push() 方法将顾客按照到达的顺序添加到队列的末尾。
3. ​服务顾客​：
   • 使用 front() 方法获取队列前端的顾客，即当前正在被服务的顾客。
   • 使用 pop() 方法移除已经服务完毕的顾客，即从队列前端移除元素。
4. ​循环处理​：当队列不为空时，继续服务新的队首顾客。
5. ​完成服务​：队列为空时，表示所有顾客都已经得到服务，程序结束

栈stack 的定义和基本用法

定义了一个整型的栈 s。默认情况下，stack 使用 deque 作为其底层容器

stack<int> s;

主要操作

• ​push()：向栈顶添加一个元素。
• ​pop()​：从栈顶移除一个元素。
• ​top()​：访问栈顶元素。
• ​empty()：检查栈是否为空。
• ​size()：返回栈中的元素数量。

s.push(10);
s.push(20);
cout << "Top element: " << s.top() << endl; // 输出 20
s.pop();
cout << "New top element: " << s.top() << endl; // 输出 10

使用不同的底层容器

stack 默认使用 deque，但你也可以指定使用其他容器，如 vector 或 list。这是通过模板参数实现的，选择哪种底层容器取决于你的具体需求，例如，使用 vector 可能在访问栈顶元素时更快一些，而 list 在删除元素时可能更高效

#include <vector>
#include <stack>
stack<int, vector<int>> stackUsingVector;
#include <list>
stack<int, list<int>> stackUsingList;

如下是一个使用栈来判断括号是否匹配的代码例子：

#include <bits/stdc++.h>
using namespace std;
bool arePairs(char opening, char closing) {
    return (opening == '(' && closing == ')') ||
           (opening == '{' && closing == '}') ||
           (opening == '[' && closing == ']');
}
bool areBalanced(const string& expr) {
    stack<char> s;
    for (char c : expr) {
        // 如果是开放括号，则推入栈中
        if (c == '(' || c == '{' || c == '[') {
            s.push(c);
        }
        // 如果是闭合括号
        else if (c == ')' || c == '}' || c == ']') {
            // 栈空或者栈顶括号不匹配，返回false
            if (s.empty() || !arePairs(s.top(), c)) {
                return false;
            }
            s.pop();  // 匹配则弹出栈顶元素
        }
    }
    // 如果栈空，则所有括号匹配完成
    return s.empty();
}
int main() {
    string expression;
    cout << "请输入括号表达式： ";  // 输入表达式
    cin >> expression;

    if (areBalanced(expression)) {
        cout << "Balanced\n";
    } else {
        cout << "Not Balanced\n";
    }

    return 0;
}

pair的基本使用方法：

定义和初始化

一个 pair 对象包含两个公共成员：first 和 second，分别代表 pair 的第一个和第二个值

pair<string, int> myPair;
myPair.first = "example";
myPair.second = 42;

使用构造函数初始化

可以直接使用构造函数来初始化 pair 的两个成员：

pair<string, int> pair1("text", 10);

make_pair 初始化

make_pair 是一个辅助函数，可以自动推断参数的类型，从而创建 pair 对象。

auto pair2 = make_pair("text", 10);

应用场景：

在容器中使用pair 在如 map 或 unordered_map 等关联容器中被广泛使用，这些容器内部实际存储的是键值对

map<string, int> age;
age["John"] = 30;
for (const auto& p : age) {
    cout << p.first << " is " << p.second << " years old. \n";
}

函数返回多个值

函数可以通过返回 pair 来同时返回两个值

pair<int, bool> func() {
    // 假设进行了一些处理
    return make_pair(42, true);
}

与其他类型结合

pair 可以与 vector、list 等容器结合使用，存储元素对，也可以是嵌套的 pair（例如 pair<int, pair<string, int>>），这在处理复杂数据结构时非常有用

结构化绑定（C++17）

从 C++17 开始，可以使用结构化绑定来解构 pair，这使得与 pair 的工作更加直接和简洁： 这种方式允许你直接在声明时解开 pair 的值，使得代码更清晰易读

auto [name, score] = make_pair("Alice", 95);
cout << name << " scored " << score << endl;

#include <bits/stdc++.h>
using namespace std;
// pair 相当于C++系统帮你定义好的含有2个变量的结构体，结构体的类型可以通过
//  <类型1,类型2>
// function    :函数
pair<string,int> FunName(string str,int x){
    
    str=str+"是：天才";
    x+=10;
    return make_pair(str,x);
}
int main(){
	pair<string,int> my; //定义的时候不赋初值
	my.first="penghaoran";
	my.second=55;
	pair<string,int> my2("kangchenyi",45);//定义的时候直接赋初值
	auto my3=make_pair("zhuzanyu",35);
	
	string str;
	int n;
	cin>>str>>n;
   //pair<string,int> my4=FunName(str,n);
	 auto my4=FunName(str,n);
	cout<<my4.first<<"   今年"<<my4.second<<"岁了";
	return 0;
}

vector 学习过程：

#include <bits/stdc++.h>
using namespace std;
//int a[100];
int main(){
    //vector<int> a(10,3); //定义一个初始长度为10，默认值为：3的整型数组 
    vector<char> cc(20,'k');
    vector<int> vec={1,2,3,4,5};
    //普通数组取得长度
        //int len= sizeof(a)/sizeof(a[0]); 
        int len=vec.size();
        for(int i=0;i<len;i++){
                cout<<vec[i]<<" ";
        }
        cout<<endl;
        vec.push_back(100);
        vec.push_back(200);
        vec.push_back(300);
        for(int i=0;i<vec.size();i++){
        //;        cout<<vec[i]<<" ";
                cout<<vec.at(i)<<" ";
        }
        cout<<endl;
        vec.pop_back();//删除数组最后一个元素
         for(int i=0;i<vec.size();i++){
                cout<<vec.at(i)<<" ";
        }
        vec.clear();// 清空数组
        cout<<endl; 
        //cout<<vec.size()<<endl;
        for(int i=0;i<vec.size();i++){
                cout<<vec.at(i)<<" ";
        }
        vec.push_back(50);
        vec.push_back(75);
        vec.push_back(150);
        vec.push_back(79);
        vec.push_back(-59);
        vec.push_back(-100);
        vec.push_back(93);
        vec.push_back(18);
        if(vec.empty()) {
                cout<<"vector is empty";
        }else{
                cout<<"vector is not empty   ";
                cout<<vec.front()<<" ";// 取的数组第一个元素 
                cout<<vec.back()<<" ";//取得数组最后一个元素 
        }
        vec.erase(vec.begin()+2);//删除第3个元素 
        // i=      0   1  2  3 
        // a[i] =  5   6  8  2
        cout<<endl;
        for(int i=0;i<vec.size();i++){
                cout<<vec.at(i)<<" ";
        }
        cout<<endl;
        sort(vec.begin(),vec.end()); //默认从小到大排序 
        for(int i=0;i<vec.size();i++){
                cout<<vec.at(i)<<" ";
        }
        cout<<endl;
        sort(vec.begin(),vec.end(),greater<int>());//从大到小排序 
        for(int i=0;i<vec.size();i++){
                cout<<vec.at(i)<<" ";
        }
        cout<<endl;
//        sort(vec.begin()+3,vec.end()); //默认从小到大排序 
//        for(int i=0;i<vec.size();i++){
//                cout<<vec.at(i)<<" ";
//        }
//        cout<<endl;
        sort(vec.begin()+3,vec.begin()+5); //默认从小到大排序 
        for(int i=0;i<vec.size();i++){
                cout<<vec.at(i)<<" ";
        }
        cout<<endl;
        vec.insert(vec.begin()+2,99999);//在第2个元素后面插入数据99999
                 for(int i=0;i<vec.size();i++){
                  cout<<vec.at(i)<<" ";
            }
        cout<<endl;
        //普通数组的排序
//        int  b[100]={};//只能赋初值为全0 
        
        //1.普通数组赋初值全0或者全-1
//        memset(b,0,sizeof(b));
//        memset(b,-1,sizeof(b));
//        fill(b,b+100,42);//给B数组赋初值42 
//        sort(b,b+100); //普通数组的排序  -下标从0开始 
//        sort(b+1,b+100+1); //普通数组的排序  -下标从0开始 
        
        
        int n=3;
        int m=4; 
        //cin>>n;
        vector<int> a(n,0);//定义一个初始长度为n，值为0的int类型数组，这不是一个空数组 
        a.push_back(6);
        for(int i=0;i<a.size();i++){
                cout<<a.at(i)<<" ";
    }
    cout<<endl;
    vector<int> b; //定义一个空数组
        b.push_back(20);
        for(int i=0;i<b.size();i++){
                cout<<b.at(i)<<" ";
    }
    cout<<endl; 
        
        //int a[3][4];//定义一个 3 行4列的普通数组
         //定义一个n行m列,初始值为0的的vector数二维组
         vector<vector<int>>  dd(n,vector<int>(m,0));
         for(int i=0;i<n;i++){
                 for(int j=0;j<m;j++){
                         cout<<dd[i][j]<<" ";
                 }
                 cout<<endl;
         }
                cout<<endl;
                //      9  3  
                //      5  6  0 0 0 7 7 7 2 -100 0 9 7 6 5 4 3 2 0 7 7 6 5 11 3 -5 
                //      3  0  7  
                // 这是一个：行为3，列为动态的 二维数组 
                vector<int> k[3];// 这是一个二维数组 
                
        return 0;
}