1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
using namespace std;
int main()
{
    int x,y;
    cin >> x >> y;
    freopen("test.txt", "w", stdout);  //将标准输出重定向到 test.txt文件
    if( y == 0 )  //除数为0则输出错误信息
        cerr << "error 分母不能为0" << endl;
    else
        cout << x /y ;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
int main(int argc, char const *argv[]){
	// 表示将文件内容读出到cin中, 所以下面的所有cin都是使用test.py文件中的数据, 不用在屏幕上重新打字了
    freopen("test.py", "r", stdin);
    int a, b;
    cin >> a >>b;
    cout << a << " "<< b <<endl;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void test(){
	int a = 125;
	cout<< hex << a <<endl; // 16进制输出 
	cout<< oct << a <<endl; // 8进制输出
	
	double b = 3.1415926;
	cout<< fixed << b <<endl; // 普通小数
	cout<< scientific << b <<endl; // 科学计数法输出
}
/*
7d
175
3.141593
3.141593e+00
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/*
test.py 的文件内容
23 24
def handle(a = 256, b = 64):
    if a==0 :
*/
int main(int argc, char const *argv[]){
    freopen("test.py", "r", stdin);
    int a, b;
    cin >> a >>b;
    cout << a << " "<< b <<endl;
    string s;
/*
如果不加下面这行 输出的就是: 
23 24

def handle(a = 256, b = 64):

加了输出的是:
23 24
def handle(a = 256, b = 64):
    if a==0 :
*/
    cin.ignore(numeric_limits <streamsize> ::max(), 'n'); // 重点中的重点
    getline(cin, s); 
    cout<< s <<endl;
    getline(cin, s);
    cout<< s <<endl;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// s="fasjlg,hgjlsd,hdsjlhj,sardehjs,,sdhr" --> {"fasjlg", "hgjlsd"}
vector<string> split(string s,char ch){
    int start=0;
    int len=0;
    vector<string> ret;
    for(int i=0;i<s.size();i++){
        if(s[i]==ch){
            ret.push_back(s.substr(start,len));
            start=i+1;
            len=0;
        }
        else len++;
    }
    if(start<s.size()) ret.push_back(s.substr(start,len));
    return ret;
}

1
2
3
4
5
6
7
int main(int argc, char const *argv[]){
    string s="123";
    int v=atoi(s.c_str()); // const char *c_str();表示返回正规字符串指针, 内容与string一致
    printf("result v=%dn",v);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// s="[[2,3], [23,43.5], [2,3,432]]" --> {2,3,23,43,2,3,432}
vector<int> getV(string str1){
    for(int i=0; i<str1.size(); i++){
        if(str1[i]-'0' > 9 || str1[i]-'0' < 0){
            if(str1[i] != '-' && str1[i] != '.')
                str1[i] = ' ';
        }
    }
    istringstream s1(str1);
    int num;
    vector<int> nums;
    while(s1 >> num){
        nums.push_back(num);
    } 
    print_v(nums);
    return nums;
}

1
2
3
4
5
6
7
8
9
10
11
// s="[[2,3], [23,43.5], [2,3,432]]" -->{{2,3}, {23,43}, {2,3,432}}
vector<vector<int>> getVV(string s="[[2,3], [23,43.5], [2,3,432]]"){
    vector<string> vS = split(s.substr(0, s.size()-1), ']');
    vector<vector<int>> ans;
    for(int i=0; i<vS.size(); i++){
        ans.push_back(getV(vS[i]));
    }
    print_vv(ans);
    return ans;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
#include <fstream>
using namespace std;

int main(){
    // 数据流写入文件
    string s = "hsdjkgjdksrh";
    ofstream fout;
    fout.open("data.txt", ios_base::app|ios_base::out);
    fout << s << endl;
    fout.close();
    return 0;
}
// 这里将会将 "hsdjkgjdksrh" 写入到文件data.txt中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    // 从文件读取数据流
    ifstream fin("data.txt");
    if (!fin.is_open()) {
        cout<< "open error" << endl;
    }

    while(fin.good()){
        string s;
        fin >> s;
        cout<< s << endl;
    }

    if(fin.eof()){
        cout<< "end..." << endl;
    } else if(fin.fail()){
        printf("判断最后一次读取数据的时候是否遇到了类型不配的情况");
    } else { // fin.fail()
        printf("出现意外的问题，如文件受损或硬件故障，最后一次读取数据的时候发生了这样的问题n");
    }
    fin.close();

1
2
3
4
5
6
7
8
// 这是将字符串写入到流, 然后在通过流转化为字符串, 实现多类型(int, string等)格式化为一个字符串
string Token::toString(){
    ostringstream oss;
    oss << "type:" << _type << " value:" << _value;
    cout<< oss.str() << endl;
    return oss.str();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 这里是字符串转化为对应的变量类型
//string str1="[[2,3], [23,43.5], [2,3,432]]" --> {2,3,23,43,2,3,432}
vector<int> getV(string str1){
    for(int i=0; i<str1.size(); i++){
        if(str1[i]-'0' > 9 || str1[i]-'0' < 0){
            if(str1[i] != '-' && str1[i] != '.')
                str1[i] = ' ';
        }
    }
    istringstream s1(str1);
    int num;
    vector<int> nums;
    while(s1 >> num){
        nums.push_back(num);
    } 
    print_v(nums);
    return nums;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;

// 打印向量
void print_vector1(vector<int> b){
    for(vector<int>::iterator it=b.begin();it!=b.end();it++)
        cout<<*it<<" ";
    cout<<endl;
}

void print_vector2(vector<int> &b){
    for(const auto&a : b){ // const保证不更改b, &a表示引用b里面的值
        cout<< a <<" ";
    }cout<<endl;
}


// 增加
void add_item(){
    //方法一
    vector<int> a;
    for(int i=0;i<10;i++)
        a.push_back(i);

    // 方法二
    int a2[6]={1,2,3,4,5,6};
    vector<int> a3;
    vector<int> a4(a2,a2+4);
    for(vector<int>::iterator it=a4.begin(); it<a4.end(); it++)
    a3.push_back(*it);

    // 方法三
    // ifstream in("data.txt");
    // vector<int> a;
    // for(int i; in>>i)
    //     a.push_back(i);
}



int main(int argc, char const *argv[])
{
    // vector定义
    vector<int> a0; //a0=[] 定义空的整形元素向量
    vector<int> a1(10); // a1=[0,0,0,0,0,0,0,0] 定义了10个整型元素的向量, 默认=0
    vector<int> a2(10, 1) ; //a2=[1,1,1,1,1,1,1,1,1] 大小为10初值为1的向量a
    vector<int> a3(a2); //a3=[1,1,1,1,1,1,1,1,1] 用b向量来创建a向量，整体复制性赋值
    vector<int> a4 = {1,2,3,4,5,6,7,8,9}; // a4=[1,2,3,4,5,6,7,8,9]
    vector<int> a5(a4.begin(), a4.begin()+3); // a5=[1,2,3]
    int i1[7]={1,2,3,4,5,9,8};
    vector<int> a6(i1,i1+7); // a6=[1,2,3,4,5,9,8] 从数组中获得初值
    vector<int> a7;
    a7.assign(a6.begin(), a6.begin()+3); // a7=[1,2,3]
    vector<int> a8; 
    a8.assign(4,2); // a8=[2,2,2,2]


    // 增加元素
    a0.push_back(1); // a0=[1,]在后面插入一个值1
    a0.insert(a0.begin(), 2); //a0=[2,1], 在a0的头部插入2
    a0.insert(a0.begin()+1,5); //a0=[2,5,1] 在a的第1个元素（从第0个算起）的位置插入数值5，如a为1,2,3,4，插入元素后为1,5,2,3,4
    a0.insert(a0.begin()+1,3,7); // a0=[2,7,7,7,5,1]在a的第1个元素（从第0个算起）的位置插入3个数，其值都为5
    a0.insert(a0.begin()+1,a1.begin()+3,a1.begin()+6); 
    //a0=[2,0,0,0,7,7,7,5,1]b为数组，在a的第1个元素（从第0个算起）的位置插入b的第3个元素到第5个元素（不包括b+6），如b为1,2,3,4,5,9,8         ，插入元素后为1,4,5,9,2,3,4,5,9,8
    

    // 排序 #include <algorithm>
    sort(a6.begin(), a6.end()); // a6=[1,2,3,4,5,8,9]默认从小到大 
    // 元素倒置
    reverse(a6.begin(),a6.end());  // [9,8,5,4,3,2,1]
    // 深拷贝 
    copy(a6.begin(),a6.end(), a1.begin()+2);  
    // a1=[0,0,9,8,5,4,3,2,1,0]

    // 查找, 返回位置
    a6.push_back(4); // a6=[9,8,5,4,3,2,1,4]
    if(find(a6.begin(), a6.end(), 4) != a6.end()){
        for(vector<int>::iterator it = find(a6.begin(),a6.end(),4); it!=a6.end(); it++){
            cout<< "a6中4存在" << *it <<endl;
        }
    }
    if(count(a6.begin(), a6.end(), 2) != 0){
        cout<< "a6 存在2" <<endl;
    }
    // 读取数据
    a4.back();//返回a的最后一个元素
    a4.front(); //返回a的第一个元素
    a4.at(1); // 读取index=1的值, 如果没有会抛出异常
    a4.clear(); // a4=[]清空a中的元素
    if(a4.empty()){
        cout<< "a4空了" <<endl;
    }
    a4.push_back(4); // a4=[4] 插入一个元素
    a4.pop_back(); // a4=[] 删除a向量的最后一个元素
    a6.erase(a6.begin()+1,a6.begin()+3); // a6=[9,4,3,2,1,4]删除a中第1个（从第0个算起）到第2个元素，也就是说删除的元素从a.begin()+1算起（包括它）一直到a.begin()+         3（不包括它）
    a7.size(); //返回a中元素的个数；
    a7.capacity(); //返回a在内存中总共可以容纳的元素个数
    a7.resize(6); // a7=[[1,2,3,0,0,0]将a的现有元素个数调至10个，多则删，少则补，其值随机
    a7.resize(8,2); // a7 = [1,2,3,0,0,0,2,2]将a的现有元素个数调至10个，多则删，少则补，其值为2
    a7.reserve(100); //将a的容量（capacity）扩充至100，也就是说现在测试a.capacity();的时候返回值是100.这种操作只有在需要给a添加大量数据的时候才         显得有意义，因为这将避免内存多次容量扩充操作（当a的容量不足时电脑会自动扩容，当然这必然降低性能） 
    // a7=[1,2,3,0,0,0,2,2]
    // a0=[2,0,0,0,7,7,7,5,1]
    a7.swap(a0); // 
    // a7=[2,0,0,0,7,7,7,5,1]
    // a0=[1,2,3,0,0,0,2,2]
    a7==a0; //b为向量，向量的比较操作还有!=,>=,<=,>,<

    print_vector1(a1);
    print_vector2(a2);

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;

// https://blog.csdn.net/sinat_41852207/article/details/86668954?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromBaidu-1.control&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromBaidu-1.control
int main(int argc, char const *argv[])
{
	// 二维向量初始化
	vector<vector<int>> v1(5,vector<int>(10,6)); // 5行. 每行10个, 10个6
	vector<vector<int>> v2 = {{1,2,3,4}, {2,3,4,5}}; //两行, 直接赋值
	
	int a1[5]={1,2,3,5,6};
	vector<int> i(a1, a1+4); //初始化一维数组, 用a1赋值
	printf("打印向量:n");
	for(auto c : i) cout<< c <<" ";
	// 二维向量的插入
	vector<vector<int>> v3;
	v3.push_back(i); // v3 = {{1,2,3,5}, }
	i[0]=5;
	i[1]=4;
	i[2]=4;
	i[3]=4;
	i[4]=4;
	v3.push_back(i); // v3 = {{1,2,3,5}, {5,4,4,4,4}}
	
	// 二维向量的打印
	cout<<"n打印二维数组"<<endl;
	for (int i = 0; i < v1.size(); i++)
	{
		for (int j = 0; j < v1[0].size(); j++)
		{
			cout<<v1[i][j]<<" ";
		}
		cout<<endl;
	}
	cout<<endl;
	cout<<"hello world"<<endl;
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <list>
void test(){
    list<int> list1 = {1,2,3,3 ,3, 3, 3, 4,5,5,5,6,7,8, 2, 2, 2};
    for(list<int>::iterator it=list1.begin(); it!=list1.end(); it++){ // 迭代器打印全部数据
        cout<< *it << " ";
    } cout << endl;

    list1.remove(2); // 删除全部的指定元素
    for(auto &a : list1){ cout<< a <<" " ;}cout<< "n";

    list1.remove_if([](int &a){return a%2==0;});// 删除list中2的倍数
    for(auto &a : list1){ cout<< a <<" " ;}cout<< "n";

    list1.unique(); // 移除连续重复的数据, 只保留一个
    for(auto &a : list1){ cout<< a <<" " ;}cout<< "n";


    list1.erase(++list1.begin(), list1.end()); // 删除第二个到最后一个
    for(auto &a : list1){ cout<< a <<" " ;}cout<< "n";
}

1
2
3
4
5
#include<unordered_map>
#include<map>
#include<unordered_set>
#include<set>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
#include<iostream>
#include<map> // 注意map的key会自动排序, 所以在遇到排序问题时参考
#include<algorithm>
#include<vector>
#include <unordered_map>
using namespace std;
//     map中 所有元素都是pair
//     pair中 第一个元素为key(键值) 用于索引   第二个元素value(实值)
//     所有元素都会根据键值自动排序
// 本质：
//      map /mulmap底层都是二叉树
// 优点：
//     可根据key值快速找到value值

//      map不允许容器中出现相同的值 
//      mulmap中允许出现重复的值2
// map大小和交换：
//      .size()   //返回容器中元素的数目
//      .empty()   //判断容器是否为空
//      .swap(st)     //交换两个容器
// 插入和删除：
//     insert(elem)  //容器中插入元素  inseert(pair<int,int>               ( , ));
//     clear()    //清除所有元素
//     erase(pos)    //删除pos迭代器所指的元素 返回下一个迭   代器位置
//     erase(key)   删除键值为key的元素

void map_test(){
    // https://blog.csdn.net/tcx1992/article/details/80928790
    // https://blog.csdn.net/sevenjoin/article/details/81937695
    typedef map<int, string> myMap; // 这其实就是将map里面的数据格式给固定下来而已, map<int, string> = myMap
    myMap test;
    //插入
    test.insert(pair<int, string>(3, "a"));
    test.insert(pair<int, string>(4, "b"));
    test.insert(pair<int, string>(5, "c"));
    test.insert(pair<int, string>(8, "d"));
    test.insert(pair<int, string>(50, "e"));

    //遍历（二叉搜索树的中序遍历，按照key值递增顺序）
    cout << "遍历" << endl;

    // for(auto i : test){  // 将temp里面的每个值, 放到i中, 这个i是新建的
	// for(auto &i : test){  // 将temp里面的每个值, 软连接到i, 修改i就是在修改temp中的值
	for(const auto &i : test){ // 将temp里面的每个值, 软连接到i, 禁用修改, 防止在遍历过程中出现改值
        cout << i.second << endl;
    cout << endl;
    auto iter = test.rbegin();//最大的N个数
    for (int i = 0; i < 3; i++)
        cout << iter++->second << endl;
    //查找
    cout << "查找" << endl;
    // 使用find，返回的是被查找元素的位置，没有则返回map.end()。
    auto it = test.find(50); //查找key=50的数据是, find(key)返回的是pair格式, 也就是(50, e), 所以it->second=
    if (it != test.end())
        cout << it->second << endl;
    // 使用count，返回的是被查找元素的个数。如果有，返回1；否则，返回0
    cout << test.count(3) << endl;
    //删除
    cout << "删除" << endl;
    if (test.erase(3))
        cout << "delete success" << endl;
    for (auto &i : test)
        cout << i.second << endl;    
}

void map_test2(){
    map<int, string> myMap;  // 创建
    myMap.insert(pair<int, string>(3, "a")); // 插入
    myMap.insert(pair<int, string>(5, "b"));
    myMap.insert(pair<int, string>(50, "d"));
    for (auto &i : myMap) cout <<i.first <<"value="<< i.second<<"; "; cout<<endl;  // 遍历
        
    //返回map最后一个值
    map<int, string>::reverse_iterator iter = myMap.rbegin(); 
    if (iter != myMap.rend()) cout<<"最后一个值是"<<iter->first << "-" << iter->second <<endl;
    // cout<<"最后一个值是"<<myMap.end()->first << "-" << myMap.end()->second <<endl; //这样是错误的, 因为rend()和end()这两个函数只是标记找没找到 不是返回最后一个元素

    // 最大的2个数
    auto iter1 = myMap.rbegin();
    for (int i = 0; i < 2; i++)
        cout << iter1++->second << endl;

    // 查找find
    auto it = myMap.find(50); //查找key=50的数据是, find(key)返回的是pair格式, 也就是(50, e), 所以it->second=
    if (it != myMap.end()) 
        cout <<it->first << "-"<<it->second << endl;

    // 判断存在, 
    cout << "3有" << myMap.count(3) << endl;
}

int main()
{
    // map_test2();
    unordered_map<int, string> map1{{1, "hel"}, {2, "ahskg"}, {3, "world"}};
    cout<<map1.at(1)<<endl; // 最简单的查找
    // cout<<map1.at(5)<<endl; // 最简单的查找
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/*
1. 两个栈实现
2. 入队列: 入第一个栈
3. 出队列: 出第二个栈, 如果第二个栈空了, 将第一个栈数据都入第二个栈, 在出
*/
class MyQueue{
private:
    stack<int> in, out;
    int q_size = 0;
public:
    void push(int x){
        in.push(x);
        q_size++;
    }
    int pop(){
        in2out();
        int r = out.top();
        out.pop();
        q_size--;
        return r;
    }
    int peek(){
        in2out();
        int r = out.top();
        return r;
    }
    bool empty(){
        return q_size==0;
    }
    void in2out(){
        if(out.empty()){ // 为空则把in->out
            while(!in.empty()){
                out.push(in.top());
                in.pop();
            }
        }
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// 利用队列实现栈
/*
    0. 栈是先入后出
    1. 入队: 使用一个队列, 每次新节点都进入到最底层(循环出队到入队n-1次)
    2. 出队: 队列的头部直接出
*/
class MyStack{
private:
    queue<int> temp;
public:
    MyStack() {}
    void push(int x){
        temp.push(x);
        for(int i=0; i<temp.size()-1; i++){
            temp.push(temp.front());
            temp.pop();
        }
    }
    int pop(){
        int r=temp.front();
        temp.pop();
        return r;
    }
    int top(){
        return temp.front();
    }
    bool empty(){
        return temp.empty();
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <vector>
#include <sstream> // 为了使用stringsteam
using namespace std;

string String_test(){
	string str="hello world";

	//直接打印字符串
	cout<<"str="<<str<<endl; 
	// printf("%sn", str); //这里会报错, 需要将string转化为const char*类型
	const char *p = str.c_str();
	printf("str=%sn", p);

	// 求字符串长度:
	cout<<"字符串长度等于: "<<str.length()<<endl;

    // 打印字符串最后一位
    cout<<"字符串最后一位"<<str[str.length()-1]<<endl;
    cout<<"字符串最后一位"<<str.back()<<endl;

    // string切片 substr(起始位置, 长度)
    cout<<"切片"<<str.substr(0, 5)<<endl;  

	//比较字符串
	if (0 == str.compare("hello world")){
		printf("字符串等于hello worldn");
	}

	// 字符串判断空
	if(!str.empty()){
		printf("字符串不为空n");
	}

    // 字符串翻转
    // reverse(str.begin(), str.end()); // algorithm定义
	// char*、char[]转换为string 
    const char* pszName = "liitdar";
    char pszCamp[] = "alliance";
    string strName = pszName;
    string strCamp = pszCamp;
    cout << "strName is: " << strName << endl;	//strName is: liitdar
    cout << "strCamp is: " << strCamp << endl;	//strCamp is: alliance

    // find检测是否存在
	// size_t find (const string& str, size_t pos = 0) const;
	// size_t find (const char* s, size_t pos = 0) const;
	// size_t find (const char* s, size_t pos, size_t n) const;
	// size_t find (char c, size_t pos = 0) const;
    string str2 = "world";
    size_t son_location = str.find(str2);
    if (son_location != string::npos){ 
    	cout<<"找到子串str2, 在str位置是: "<<son_location<<endl; //找到子串str2, 在str位置是: 6
    }

    // 插入方法 insert
    str.insert(6, "zjq's "); //hello zjq's world
    str.insert(5, 4, 'a'); //在5的位置, 插入4个a
    cout<<str<<endl;

    // int2string stringstream
    int n1 = 1234;
    // n1.str(); // 这肯定不对
    stringstream str3; //注意这里导入头文件<sstream>
    str3 << n1;
    string str4 = str3.str();
    cout<<"将int类型转化为string类型: "<<str4<<endl;

    string str5;
    str3 >> str5;
    cout<<str5<<endl; //总之都要将int转化为string类型


    // 方法2 to_string
    int numb2 = 456;
    string str6;
    str6 = to_string(numb2);    // C++11 标准
    cout << "str6 is: " << str6 << endl; //str6 is: 456
    return str6;
}


int main(int argc, char const *argv[])
{
	string str = String_test();
    cout<<str<<endl;
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <algorithm>
#include <vector>
#include <list>
#include <iostream>
#include <map>
#include <set>
#include <unordered_set>
#include <unordered_map>
#include <numeric>
#include <string.h>
#include <queue>
#include <stack>