^-^
We see things not as they are, but as we are.
ACM-library
最近更新：2025-11-12   |   字数总计：3.1k   |   阅读估时：13分钟   |   阅读量：次
  1. 一、字符串处理
    1. 1.字符输入
      1. (1) cin
      2. (2) cin.get()
      3. (3) cin.getline()
      4. (4) getline()
      5. (6) 总结
    2. 2.字符串string
      1. (1) string 初始化
      2. (2) string 首尾字符
      3. (3) string 迭代器
      4. (4) string 插入与删除
      5. (5) string 替换和拼接
      6. (6) string 遍历
      7. (7) string 排序和比较
      8. (8) string 查找
      9. (9) string 判空和清空
  2. 二、STL容器库
    1. 1. vector
      1. (1) vector 初始化
      2. (2) vector 调用元素
      3. (3) vector 迭代器
      4. (4) vector 插入和删除
      5. (5) vector 遍历
      6. (6) vector 判空和清空
      7. (7) vector 一些算法
    2. 2.queue
      1. (1) queue 调用
      2. (2) priority_queue 调用
      3. (3) deque 调用
    3. 3.stack
      1. (1) stack 调用
    4. 4.set
      1. (1) set 插入和删除
      2. (2) set 一些算法
    5. 5.map
      1. (1) map 调用
    6. 6.bitset
      1. (1) bitset 调用
  3. 三、二进制
    1. 1. 位处理
      1. (1) 求不小于x的最小2次幂
      2. (2) 求x的二进制长度

一、字符串处理

1.字符输入

(1) cin

用法一：接收一个字符串，无论是char a[10]，还是string b 都一样，遇到”Space”,”Tab”,”Enter”都会结束

1
2
3
4
5
6
7
8
9
10
11
12
#include<bits/stdc++.h>
using namespace std;

int main(){
	char a[10];
	string b;
	cin>>a;
	cin>>b;
    cout<<a<<endl;
    cout<<b<<endl;
	return 0;
}
(2) cin.get()

用法一：用 ch = cin.get() 或 cin.get(ch) 来接收单个字符

1
2
3
4
5
6
7
8
9
#include<bits/stdc++.h>
using namespace std;

int main(){
	char ch;
	ch = cin.get();  // 或者 cin.get(ch)
	cout<<ch<<endl;
	return 0;
}

用法二：用cin.get(a, n)，其中a是字符数组名，n是要输入的字符个数，可接收空格

注意1：不能用于string类型，只能输入字符数组

注意2：假如定义cin(a, 20)，实际只能输入19个字符

1
2
3
4
5
6
7
8
9
#include<bits/stdc++.h>
using namespace std;

int main(){
	char a[20];
	cin.get(a,10);  // 向字符数组a中输入9个字符
	cout<<a<<endl;
	return 0;
}

用法三：无参数调用，主要用于舍弃输入流中不需要的字符，或用于吃掉回车，相当于getchar()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
using namespace std;

int main(void)
{
     
    char arr[10];
    cin.get(arr,10);
    cin.get();//用于吃掉回车，相当于getchar();
    cout<<arr<<endl;
    cin.get(arr,5);
    cout<<arr<<endl;
    system("pause");
    return 0;
}

//输入abcdefghi
//输出abcdefghi
//输入abcde
//输出abcd
//请按任意键继续
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
using namespace std;

int main(void)
{
     
    char arr[10];
    cin.get(arr,10);
    //cin.get();//用于吃掉回车，相当于getchar(); 现在把这行注释掉试试看
    cout<<arr<<endl;
    cin.get(arr,5);
    cout<<arr<<endl;
    system("pause");
    return 0;
}

//输入abcdefghi(\n)
//输出abcdefghi  //换行符没被舍去留在了输入流中，自动填充并结束了第二次输入
//请按任意键继续
(3) cin.getline()

用法一：调用、功能、注意点 和 cin.get() 的第二种用法一模一样

1
2
3
4
5
6
7
8
9
#include<bits/stdc++.h>
using namespace std;

int main(){
	char a[20];
	cin.getline(a,10);  // 向字符数组a中输入9个字符
	cout<<a<<endl;
	return 0;
}

用法二：cin.getline(m, n, ch)，其中m表示字符数组位置，n表示接收字符个数，ch表示结束字符

在多维数组当中，m可以是a[i]

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

int main(){
    char m[3][20];
    for(int i=0;i<3;i++)
    {
    cout<<"\n请输入第"<<i+1<<"个字符串："<<endl;
    cin.getline(m[i],20); //结束字符默认为回车
    }
    
    cout<<endl;
    for(int j=0;j<3;j++)
    cout<<"输出m["<<j<<"]的值:"<<m[j]<<endl;
    system("pause");
    return 0;
}
(4) getline()

用法一：需要加头文件，调用 getline(cin, a)输入字符串或字符数组，弥补了前两种输入无法处理string类型的弊病

1
2
3
4
5
6
7
8
9
10
#include<iostream>
#include<string>
using namespace std;
int main()
{
	string s;
	getline(cin,s);
	cout << s << endl;
	return 0;
}
(6) 总结
字符数组 字符串 能否输入空格 备注
cin ✔️ ✔️ ❌ 调用简单
cin.get() ✔️ ❌ ✔️ 可用于定量输入字符数组
cin.getline() ✔️ ❌ ✔️ 可用于多维字符数组输入
getline() ❌ ✔️ ✔️ 可用于字符串输入
getchar() ❌ ❌ ✔️ 可用于吞空格，尽量少用

2.字符串string

(1) string 初始化
1
2
3
string str("123");   //"123"
string str(3,'1');   //"111"
string str = "123";  //"123"
(2) string 首尾字符
1
2
3
4
5
str.front();   //第一个字符 
str.back();    //最后一个字符

str.size()     //字符串大小
str.length()   //字符串长度
(3) string 迭代器
1
2
3
string::iterator iter   //一个string的迭代器，可以用auto代替
str.begin()             //指向str第一个元素位置的迭代器
str.end()               //指向str最后一个元素后一个位置的迭代器
(4) string 插入与删除
1
2
3
4
5
6
7
str.push_back('a');                       //在尾部插入一个元素
str.insert(str.begin(), 'a');             //在指定位置前面插入一个元素

str.pop_back();                           //删除最后一个元素 
str.erase(str.begin());                   //删除迭代器指向元素
str.erase(str.begin()+1, str.end()-2);    //删除指定区间的元素
str.erase(k, n);                          //删除从索引k开始的n个字符
(5) string 替换和拼接
1
2
3
4
5
6
7
str.replace(str.begin(), str.begin + 5, "boy"); //替换迭代器指定的区间
str.replace(k, n, "girl");                      //替换从索引k开始的n个字符

str1.append(str2);                              //"123","abc"->"123abc"
str1 = str1 + str2;                             //"123","abc"->"123abc"

str.substr(k, n);  //返回从索引k开始的n个元素组成的字符串切片
(6) string 遍历
1
2
3
4
5
6
7
for(int i = 0; i < str.size(); i ++ )                             //索引遍历 

for(string::iterator iter = str.begin(); iter != str.end(); iter ++ ) 
for(auto iter = str.begin(); iter != str.end(); iter ++ )         //迭代器遍历 

for(auto x : str) //便捷遍历，x作为形参被赋值不改变原字符串 
for(auto &x : str) //便捷遍历，x作为实参被赋值将会改变原字符串
(7) string 排序和比较
1
2
3
4
sort(str.begin(), str.end());

str1 < str2            //字典序比较，<、<=、==、>、>=都可以用，和字符串长度无关
str1.compare(str2)     //相等为0，str1>str2为1，反之-1
(8) string 查找
1
2
3
4
5
6
7
8
9
10
str.find("123")           //从前往后找，若找到，返回首字母下标；反之，返回-1
str.rfind("123")          //从后往前找
    
str.find_first_of("123")        //查找第一个属于该字符串的字符返回下标
str.find_first_not_of("123")    
    
str.find_last_of("123")         //查找最后一个属于该字符串的字符返回下标
str.find_last_not_of("123")

str.count('a')                  //返回str里a字符的个数
(9) string 判空和清空
1
2
str.empty();    //返回布尔值 
str.clear();

二、STL容器库

1. vector

(1) vector 初始化
1
2
3
4
5
6
7
8
9
10
11
vector<int> v(n);      //定义了10个整型元素的向量,但没有给出初值，其值是不确定的。
vector<int> v(10,1);   //定义了10个整型元素的向量,且给出每个元素的初值为1
vector<int> a(b);      //用b向量来创建a向量，整体复制性赋值
vector<int> a(b.begin(),b.begin+3);  //定义a元素的值等于b中第0个到第2个（共3个）元素

int b[7]={1,2,3,4,5,9,8};
vector<int> a(b,b+7);                 //从数组中获得初值

int rows = 3, cols = 4;
vector<vector<int>> arr(rows, vector<int>(cols, 0)); //vector构建多维数组
arr[1][2] = 5;  // 修改第2行第3列为5
(2) vector 调用元素
1
2
3
4
v.front()    //第一个元素 
v.back()     //最后一个元素
v.size()     //向量大小
v[i]         //向量v的第i个元素
(3) vector 迭代器
1
2
3
vector::iterator iter   //一个vector的迭代器，可以用auto代替
v.begin()             //指向v第一个元素位置的迭代器
v.end()               //指向v最后一个元素后一个位置的迭代器
(4) vector 插入和删除
1
2
3
4
5
6
7
8
v.push_back(a);                         //在尾部插入一个元素
v.insert(v.begin(), a);                 //在指定位置前面插入一个元素
v.insert(v.begin(),k, a);               //在指定位置前面插入k个元素

v.pop_back();                           //删除最后一个元素 
v.erase(v.begin());                     //删除迭代器指向元素
v.erase(v.begin()+1, v.end()-2);        //删除指定区间的元素
v.erase(k, n);                          //删除从索引k开始的n个元素
(5) vector 遍历
1
2
3
4
for(int i = 0; i < v.size(); i ++ )       //索引遍历,确保向量每个索引都已经有对应值

for(vector::iterator iter = v.begin(); iter != v.end(); iter ++ ) 
for(auto iter = v.begin(); iter != v.end(); iter ++ )         //迭代器遍历
(6) vector 判空和清空
1
2
v.empty();    //返回布尔值 
v.clear();
(7) vector 一些算法
1
2
3
4
5
6
7
sort(v.begin(), v.end());    //排序
reverse(v.begin(), v.end())  //反转
a.swap(b);                   //a,b为向量，将a中的元素和b中的元素进行整体性交换
find(v.begin(),v.end(),k);   
//在向量v的一个范围中查找k，若存在返回其位置,否则返回一个绝对值很大的负数

//向量也可以比大小，和string相似，从头元素开始比大小

2.queue

(1) queue 调用
1
2
3
q.push(2); //在队尾插入一个元素 
q.pop(); //在队首删除一个元素
q.empty()
(2) priority_queue 调用

priority_queue容器相当于大根堆（或者小根堆）

大根堆每次堆顶是最大元素，小根堆每次堆顶是最小元素

1
2
3
4
5
6
7
8
priority_queue<int> q;                             //生成大根堆（根为最大值）
priority_queue<int, vector<int>, greater<int>> q;  //生成小根堆

q.push(2); //把一个元素插入堆底部
q.pop(); //删除堆顶的元素

q.top(); //返回堆顶元素 
q.empty();
(3) deque 调用

与vector相比，deque在头部增删元素仅需要 O(1)的时间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
dq.front();//头尾元素
dq.back();

dq.begin();//迭代器
dq.end();

dq.push_front(2); //头插入 
dq.push_back(2); //尾插入 

dq.pop_front(); //头删除
dq.pop_back(); //尾删除

dq.empty();
dq.clear();

3.stack

(1) stack 调用
1
2
3
4
sk.push(2); //把一个元素放入栈 
sk.pop(); //删除栈顶的元素 
sk.top(); //返回栈顶元素 
sk.empty()

4.set

集合分为去重元素集合set和可重元素集合multiset,用法相同

set为有序集合，unordered_set为无序集合(依赖哈希函数实现)

(1) set 插入和删除
1
2
3
4
5
6
7
st.insert(2);         //插入一个元素

st.erase(st.begin()); //删除迭代器指向元素 
st.erase(2);          //删除所有为2的元素 

st.empty();
st.clear();
(2) set 一些算法
1
2
3
4
5
st.find(2)         //从前往后找，若找到，返回指向该处的迭代器；反之，返回迭代器st.end()
st.lower_bound(x)  //二分查找大于等于x的元素中最小的一个，并返回指向该元素的迭代器。
st.upper_bound(x)  //二分查找大于x的元素中最小的一个，并返回指向该元素的迭代器。

st.count(2);       //返回容器里2的个数

5.map

表分为去重元素表map和可重元素表multimap,用法相同

map为有序表，unordered_map为无序表(依赖哈希函数实现)

(1) map 调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
map<key_type, value_type> mp;
map<int, int> mp;

map<int, int>::iterator iter
mp.begin() 
mp.end() 

mp.begin().first    //key的迭代器

(*mp.begin()).first    //key的值
mp.begin()->first

mp[2] = 5; //直接插入
mp.insert(pair<int, int>(2, 5)); //用pair插入

mp.erase(iter); //删除迭代器所指的键值对 

mp.find(2);  //从前往后找，若找到，返回指向该处的迭代器；反之，返回迭代器mp.end()
mp.count(2); //返回key为2的个数（map中只可能是0或者1） 

mp.empty();
mp.clear();

6.bitset

(1) bitset 调用
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
bitset<4> bt;        //生成4位二进制数，初始化为0000
bitset<8> bt(12);    //生成8位二进制数，且将10进制数12转化为2进制数存入其中
bitset<8> bt(str);   //str只能是完全由01组成的字符串或者字符数组

bt1 |= bt2; //两个二进制数取或操作 
bt1 &= bt2; //两个二进制数取与操作 
bt1 ^= bt2; //取异或
bt1 = ~bt1; //取反
bt1 <<= x; //左移右移 
//>>表示右移，如果该数为正，则高位补0，若为负数，则高位补1；
//>>>表示无符号右移，即若该数为正，则高位补0，而若该数为负数，则右移后高位同样补0
 
bt.test(x) //判断第x个位置是0还是1，也就是输出第x个位置，注意逆序

bt.flip(); //将二进制每一位取反
bt.flip(x); //将二进制第x位取反
bt.set(); //将二进制每一位置为1 
bt.set(x); //将第x个位置置为1
bt.reset(); //将二进制每一位置为0
bt.reset(x); //将第x个位置置为0


bt.size() //二进制数组的长度，就是定义的长度
bt.count(); //查询二进制数组中，1的个数
string str = bt.to_string(); //将二进制数组转化为字符串

三、二进制

1. 位处理

(1) 求不小于x的最小2次幂
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
unsigned long long up2pow(unsigned long long x){     // 求 大于等于x的 2次幂
    if(x <= 1) return 1;
    x--;
    x |= x >> 1;   x |= x >> 2;
    x |= x >> 4;   x |= x >> 8;
    x |= x >> 16;  x |= x >> 32;
    return x + 1;
}

unsigned long long down2pow(unsigned long long x){     // 求 小于等于x的 2次幂
    if(x == 0) return 0;
    x |= x >> 1;   x |= x >> 2;
    x |= x >> 4;   x |= x >> 8;
    x |= x >> 16;  x |= x >> 32;
    return (x + 1) >> 1;
}
(2) 求x的二进制长度
1
2
3
4
5
6
7
8
int bitlen(unsigned long long x){
    int len = 0;
    while(x){
        len++;
        x >>= 1;
    }
    return len;
}
2025-11-12 该篇文章被 Apeiron 归为分类: ACM

上一篇：CF-1 下一篇：ACM-template
© 2025 ❤ Apeiron
🔮There is no end, only extending.🔮 本站由Hexo驱动｜使用Hexo-theme-A4主题