一.线性表
可变数组vector
作为数据结构的数组,stlr容器的可变长度数组vector ，需要定义头文件include
常用方法：
1.建立数组v：vector<int>v(N,i); //可变数组v，内部元素类型为int，最开始有n个元素，每个元素初始化为i。可以省略i，也可以同时省略（N，i），此时可以数组长度就是0。
2.插入元素a到末尾：v.push_back(a); //将元素a插入到数组v的末尾，并增加数组长度。
3.返回数组长度：v.size() //返回数组v的长度。
4.重新调整数组大小：v.resize(n,m) //重新调整数组大小为n，如果n比原来小，则删除多余信息，如果n比原来大，新增的部分初始化为m，m是可以省略的。
洛谷p3156 询问学号 vector
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<queue>
#include<vector>
using namespace std;
int n,m,nn,mm;
vector<int>q;
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++){
cin>>nn;
q.push_back(nn);//压入
}
for(int i=1;i<=m;i++){
cin>>mm;
cout<<q[mm-1]<<endl; //像数组一样输出
}
return 0;
}
洛谷p3613 寄包柜
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<queue>
#include<vector>
using namespace std;
int n,q,qq,i,j,k;
int main(){
cin>>n>>q;
vector< vector<int> >a(n+1);
while(q--){
cin>>qq;
if(qq==1){
cin>>i>>j>>k;
if(a[i].size()<j+1)a[i].resize(j+1);//不能让a[i]的长度小于j
a[i][j]=k;
}else{
cin>>i>>j;
cout<<a[i][j]<<endl;
}
}
return 0;
}
栈
栈是一种先进后出、后进先出的线性表,需要定义头文件stack
常用方法：
1.stack <int> s //建立一个栈s，内部元素类型是int
2.s.push(a) //将元素a压入栈
3.s.pop() //将栈顶元素弹出
4.s.top() //查询栈顶元素
5.s.size() //查询s的元素个数
6.s.empty() //查询s是否为空
洛谷p1449 后缀表达式
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<queue>
#include<vector>
#include<stack>
using namespace std;
char a[1050];
int sum,k;
stack<int>q;//栈模拟即可
int main(){
cin>>a;
for(int i=0;a[i]!='@';i++){
if(a[i]=='.'){
sum=0,k=1;
for(int j=i-1 ; j>=0 && a[j]>='0'&&a[j]<='9' ; j--){
sum=sum+(a[j]-48)*k;
k*=10;
}
q.push(sum);
continue;
}
if(a[i]>='0'&&a[i]<='9')continue;
sum=q.top();
q.pop();
if(a[i]=='+')sum+=q.top();
if(a[i]=='-')sum=q.top()-sum;
if(a[i]=='*')sum*=q.top();
if(a[i]=='/')sum=q.top()/sum;
q.pop();
q.push(sum);
}
cout<<q.top();
return 0;
}
队列
队列是一种先进先出的线性表，需要定义头文件queue
常用方法：
1.queue<int>q; //建立队列q
2.q.push() //压入a到q的末尾
3.q.pop() //删除队列q首元素
4.q.front() //查询q的队首元素
5.q.back() //查询q的队尾元素
6.q.size() //查询s的元素个数
7.q.empty() //查询s是否为空
洛谷p1996 约瑟夫问题
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<queue>
#include<vector>
#include<stack>
using namespace std;
int n,m;
int main(){
cin>>n>>m;
queue<int>q;
for(int i=1;i<=n;i++){
q.push(i);
}
while(!q.empty()){
for(int i=1;i<m;i++){
q.push(q.front());//队列先进先出
q.pop();//弹出的是前面的
}
cout<<q.front()<<" ";
q.pop();
}
return 0;
}
二.集合（并查集、哈希表、前缀和、set、map）
有时候，不关心数据的前后关系和层次关系，一些元素只是单纯的聚集在一起，这样的元素聚集体叫做集合。当希望知道某个数据是否在一个集合中，或者两个元素是否在同一个集合中，就需要使用一些集合数据结构维护集合之间的关系
并查集
思路模板
处理不相交可合并的集合叫做并查集
1.查询是否同一集合（是不是同一个家族）
int find(int x){
if(x==fa[x])return x;
else return fa[x]=find(fa[x]);//如果更新过，查更新的数组的值，最后总会返回父结点
}
2.更新父节点
void join(int c1,int c2){
int f1=find(c1),f2=find(c2);//查询是不是同一个族长
if(f1!=f2)fa[f1]=f2;//不是就更新合并
}
洛谷p1151 亲戚
将所有亲戚关系的人归于同一个集合中，如果想查询两个人是否有亲戚关系，只需要判断这两个人是否在同一个家族中。
那么怎么判断两个人是否在同一个家族中，每个家族需要选出一个族长来代表整个家族，这样只需要知道两个人的族长是不是同一个人，就可以判断出来。
规定最开始的时候，所有人都自成一族
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<string>
using namespace std;
int n,m,p,x,y,fa[5050];
int find(int x){
if(x==fa[x])return x;
else return fa[x]=find(fa[x]);//如果更新过，查更新的数组的值，最后总会返回父结点
}
void join(int c1,int c2){
int f1=find(c1),f2=find(c2);
if(f1!=f2)fa[f1]=f2;
}
int main(){
cin>>n>>m>>p;
for(int i=1;i<=n;i++)fa[i]=i;
for(int i=1;i<=m;i++){
cin>>x>>y;
join(x,y);
}
for(int i=1;i<=p;i++){
cin>>x>>y;
if(find(x)==find(y))cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
return 0;
}
洛谷p1536 村村通
这题按规定输入输出，以0结束。
题目要求计算还需要建设多少道路，我们通过find（i）== i来判断，如果族长就是自己，说明这是一条道路，我们需要连通块道路只有一个，多余的就就是需要建设的 所以输出ans要减1
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<string>
using namespace std;
int n,m,x,y,fa[1050];
int find(int x){
if(x==fa[x])return x;
else return fa[x]=find(fa[x]);
}
void join(int c1,int c2){
int f1=find(c1),f2=find(c2);
if(f1!=f2)fa[f1]=f2;
}
int main(){
while(true){
int ans=0;
cin>>n;
if(n==0)return 0;
cin>>m;
for(int i=1;i<=n;i++)fa[i]=i;
for(int i=1;i<=m;i++){
cin>>x>>y;
join(x,y);
}
for(int i=1;i<=n;i++){
if(find(i)==i){
ans++;
}
}
cout<<ans-1<<endl;
}
return 0;
}
洛谷p1892 团伙
敌人的敌人是朋友，那么创建二维数组，是敌人赋值为1，枚举所有的人，如果输入的一个和枚举的其中一个是敌人，那么输入的另一个和枚举的这其中一个是朋友
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<string>
using namespace std;
int n,m,a[1050][1050],fa[105000],p,q;
char opt;
int find(int x){
if(x==fa[x])return x;
else return fa[x]=find(fa[x]);
}
void join(int c1,int c2){
int f1=find(c1),f2=find(c2);
if(f1!=f2)fa[f1]=f2;
}
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++)fa[i]=i;
for(int i=1;i<=m;i++){
cin>>opt>>p>>q;
if(opt=='F'){
join(p,q);
}else{
a[p][q]=a[q][p]=1;//无向一定都赋值
for(int i=1;i<=n;i++){
if(a[p][i])join(q,i);//如果x和i是敌人，那么y和i是朋友
if(a[q][i])join(p,i);//同理
}
}
}
int ans=0;
for(int i=1;i<=n;i++){
if(find(i)==i)ans++;
}
cout<<ans;
return 0;
}
哈希表
思路模板
摘自深入浅出程序设计竞赛基础篇
先来思考一个问题：给定N个自然数，值域是10的7次方，求出N个自然数中有多少个不同的字符串。
因为是10的七次方，可以排序后，开大数组解决，如果出现过了就加1，表示统计过了。
如果把数据改成10的九次方，可以取一个模，如果两个数取模后是相同的值，那么认为两个数相同，可以发现，这是不可行的，因为两个不同的数可以取模后得相同的数。
如何优化呢，可以把int数组改成vector< int >数组，取模后相同的数都放在可变数组里面。然后每次判断一个数x是否存在的时候，遍历x%mod位置的vector看是否有x即可
#include<bits/stdc++.h>
using namespace std;
#define mod 233333
using namespace std;
int n,x,ans;
vector<int>linker[mod+2];
void insert(int x){
for(int i=0;i<linker[x%mod].size();i++){
if(linker[x%mod][i]==x)return;
}
linker[x%mod].push_back(x);
ans++;
}
int main(){
cin>>n;
for(int i=1;i<=n;i++){
cin>>x;
insert(x);
}
cout<<ans<<endl;
return 0;
}
这样，取模后的数都被放在vector里面，如果相同了就跳出，不相同就压入这个元素，答案加1
这样的数据结构，就被称为哈希表
洛谷p3370 字符串哈希
这题将字符串映射成ascii码数字。
如abAB01 可以映射成 97,98，65,66，48,49
hash=（hash*k+s[i]）%mod
基数k可以任选，不少于128（ASCII码字符集的数量）
模数取一个比较大的质数可以减少冲突的可能性，常用的模数有10007,999983
建立vector存储每个hash值的所有字符串
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<string>
#include<vector>
#define mod 2333
#define base 233
#define MAXN 1510
using namespace std;
int n,ans;
char s[MAXN];
vector<string>linker[mod+2];
void insert(){
int hash=1;
for(int i=0;s[i];i++){
hash=(hash*base+s[i])%mod;//计算出hash值
}
string t=s;
for(int i=0;i<linker[hash].size();i++){
if(linker[hash][i]==t)return;
}
linker[hash].push_back(t);
ans++;
}
int main(){
cin>>n;
for(int i=1;i<=n;i++){
cin>>s;
insert();
}
cout<<ans<<endl;
return 0;
}
set
思路模板
1.set< int >ds 建立一个名字叫做ds的、元素类型为int的集合
2.ds.insert（x） 在集合中插入一个元素，如果这个元素已经存在，则什么都不干
3.ds.erase（x） 在集合中删除元素x，如果这个数不存在，则什么都不干
4.ds.erase（it） 删除集合中地址为it的元素
5.ds.end（） 返回集合中最后一个元素的下一个元素的地址。这个很少用，是配合其他方法进行比较，以确认某个元素是否存在
6.ds.find（x） 查询x在集合的地址，如果不存在，则返回ds.end（）
7.ds.lower_bound(x) 查询不小于x的最小的数在集合中的地址，如果不存在，则返回ds.end（）
8.ds.upper_bound(x) 查询大于x的最小的数在集合中的地址，如果不存在，则返回ds.end（）
9.ds.empty() 如果集合是空的，则返回1，否则返回0
10.ds.size（） 返回集合中元素的个数
洛谷p5250 木材仓库
进货操作可以用insert，查询操作用lower_bound，出货删除用erase
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<string>
#include<vector>
#include<set>
using namespace std;
int n,opt,lenth;
set<int>ds;
int main(){
cin>>n;
while(n--){
cin>>opt>>lenth;
if(opt==1){
if(ds.find(lenth)!=ds.end())cout<<"Already Exist"<<endl;
else ds.insert(lenth);
ds.insert(lenth);
}else if(ds.empty()){
cout<<"Empty"<<endl;
}else{
set<int>::iterator i = ds.lower_bound(lenth), j=i;
if(j!=ds.begin())--j;
if(i!=ds.end() && lenth-(*j)>(*i)-lenth)j=i;
cout<<(*j)<<endl;
ds.erase(j);
}
}
return 0;
}
洛谷p1059 明明的随机数
#include<bits/stdc++.h>
using namespace std;
int a;
set<int>ds;
int main(){
int n;
cin>>n;
for(int i=1;i<=n;i++){
cin>>a;
ds.insert(a);
}
cout<<ds.size()<<endl;
while(!ds.empty()){
cout<<*ds.begin()<<" ";
ds.erase(ds.begin());
}
return 0;
}
map
map不存在相同元素
使用iterator迭代器遍历map：
map <int,string>::iterator it;
for(it=mpp.begin();it!=mpp.end();++it){
cout<<(it->second)<<endl;
}
迭代器中，first 和 second，分别指向键值和数值
思路模板
1.map<A,B>ds 建立一个名字叫做ds、下标类型为A，元素类型为B的映射表（将A类型映射到B类型）
2.ds[A]=B 把这个数组中下标为A的位置的值变成B，这里的下标可以是任意类型
3.ds[A] 访问数组中下标为A的元素
4.ds.end() 返回映射表中最后一个元素的下一个元素的地址，很少单独使用，而是配合其他方法做比较
5.ds.find(x) 查询x在映射表中的地址，如果这个数不存在，则返回ds.end()
6.ds.empty() 如果映射表是空的则返回1，否则返回0
7.ds.size() 返回映射表中的元素个数
8.ds.count(Key)返回值为1或者0，1返回存在，0返回不存在
9.ds.erase(x) 删除x
无序map：unordered_map<string,int>mp;
洛谷p5266 学籍管理
使用map模拟即可
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<string>
#include<vector>
#include<set>
#include<map>
using namespace std;
int n,opt,num,ans;
string name;
map<string,int>ds;
int main(){
cin>>n;
while(n--){
cin>>opt;
if(opt==1){
cin>>name>>num;
if(!ds[name])ans++;
ds[name]=num;
cout<<"OK"<<endl;
}else if(opt==2){
cin>>name;
if(ds[name])cout<<ds[name]<<endl;
else cout<<"Not found"<<endl;
}else if(opt==3){
cin>>name;
if(ds[name]){
ans--;
ds[name]=0;
cout<<"Deleted successfully"<<endl;
}else{
cout<<"Not found"<<endl;
}
}else{
cout<<ans<<endl;
}
}
return 0;
}
前缀和与差分
思路模板
简化复杂度
一维前缀和
直接建立新数组，保存的值为旧数组的前缀和（加起来）
二维前缀和
大矩形 = 两个矩形 - 重叠部分的一个矩形 + 小矩形（二维前缀和的初始化）
Sij = （S i-1，j） + （S i，j-1） - （S i-1，j-1） + （a i，j）
大矩形中的小矩形 = 减掉两个矩形 + 多减掉的那个小矩形(子矩阵的和)
s[x2][y2]-s[x1-1][y2]-s[x2][y1-1]+s[x1-1][y1-1];
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
cin>>a[i][j];
s[i][j]=s[i][j-1] + s[i-1][j] - s[i-1][j-1] + a[i][j];
}
}
for(int i=1;i<=q;i++){
int x1,y1,x2,y2;
cin>>x1>>y1>>x2>>y2;
cout<<s[x2][y2] - s[x2][y1-1] - s[x1-1][y2] + s[x1-1][y1-1]<<endl;
}
251
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
