蓝桥杯模板速查

暴力搜索模板

并查集模板

#include<bits/stdc++.h>
using namespace std;
void init(vector<int>& father){
    for(int i=0;i<father.size();i++){
        father[i]=i;
    }
}
int find(vector<int>& father,int x){
    if(father[x]==x) return x;
    else return father[x]=find(father,father[x]);
}
void join(vector<int>& father,int x,int y){
    int fx=find(father,x);
    int fy=find(father,y);
    if(fx!=fy) father[fx]=fy;
}

dfs基础模板

寻找一个图中的岛屿的个数

#include<bits/stdc++.h>
using namespace std;
void collect(int i,int j,vector<vector<int>> &island,vector<vector<bool>> &visited,vector<vector<int>> &dir){
    visited[i][j]=true;
    for(int d=0;d<4;d++){
        int r=i+dir[d][0];
        int c=j+dir[d][1];
        if(r>=0 && c>=0 && r<island.size() && c<island.size() && island[r][c]==1 && !visited[r][c])
            collect(r,c,island,visited,dir);
    }
    return ;
}
int main(){
    vector<vector<int>> dir{{-1,0},{1,0},{0,-1},{0,1}};
    vector<vector<int>> island={{1,1,0,0,0},
                                {1,1,0,0,0},
                                {0,0,1,0,0},
                                {0,0,0,1,1}};
    int n=island.size();
    vector<vector<bool>> visited(n,vector<bool>(n,false));
    int count=0;
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            if(island[i][j]==1 && !visited[i][j]){
                collect(i,j,island,visited,dir);
                count++;
            }
    cout<<count<<endl;
    return 0;
}

bfs基础模板

#include<bits/stdc++.h>
using namespace std;
int main(){
    vector<vector<int>> dir{{-1,0},{1,0},{0,-1},{0,1}};
    vector<vector<int>> island={{1,1,0,0,0},
                                {1,1,0,0,0},
                                {0,0,1,0,0},
                                {0,0,0,1,1}};
    int n=island.size();
    vector<vector<bool>> visited(n,vector<bool>(n,false));
    int count=0;
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            if(island[i][j]==1 && !visited[i][j]){
                queue<pair<int,int>> que;
                que.push({i,j});
                while(que.size()!=0){
                    pair<int,int> p=que.front();
                    que.pop();
                    if(visited[p.first][p.second])
                        continue;
                    visited[p.first][p.second]=true;
                    for(int d=0;d<4;d++){
                        int r=p.first+dir[d][0];
                        int c=p.second+dir[d][1];
                        if(r>=0 && c>=0 && r<island.size() && c<island.size() && island[r][c]==1 && !visited[r][c])
                            que.push({r,c});
                    }
                }
                count++;
            }
    cout<<count<<endl;
    return 0;
}

动归背包模板

01背包基础模板

#include<bits/stdc++.h>
using namespace std;
int main(){
    vector<int> weight={1,3,4};
    vector<int> value={10,20,25};
    int maxweight=4;
    vector<int> dp(maxweight+1,0);
    for(int i=weight[0];i<maxweight+1;i++) dp[i]=value[0];
    for(int i=1;i<weight.size();i++){
        for(int j=maxweight;j>=weight[i];j--){
            dp[j]=max(dp[j],dp[j-weight[i]]+value[i]);
        }
    }
    cout<<dp[maxweight]<<endl;
    return 0;
}

完全背包基础模板

#include<bits/stdc++.h>
using namespace std;
int main(){
    vector<int> weight={1,3,4};
    vector<int> value={10,20,25};
    int maxWeight=8;
    vector<int> dp(maxWeight+1,0);
    for(int i=0;i<weight.size();i++){
        for(int j=weight[i];j<=maxWeight;j++){
            dp[j]=max(dp[j],dp[j-weight[i]]+value[i]);
        }
    }
    cout<<dp[maxWeight]<<endl;
    return 0;
}

stl数据结构

string

#include<bits/stdc++.h>
using namespace std;
int main(){
    string s="Hello World";
    cout<<s.length()<<endl;  
    cout<<s.empty()<<endl;  
    s.append("!");
    cout<<s<<endl;  
    auto it=s.find("World");  
    if(it!=string::npos){
        cout<<s.substr(it)<<endl; 
        cout<<s.substr(0,it)<<endl;  
    }
    s.replace(0,5,"Hi");  
    cout<<s<<endl;  
    s.insert(3,"My ");  
    cout<<s<<endl;  
    s.erase(3,3);
    cout<<s<<endl;  
    return 0;
}

stack

stack是一个容器型适配器,因此不能初始化大小.容器型适配器还不可以索引使用,不可用迭代器迭代.

#include<bits/stdc++.h>
using   namespace std;
int main(){
    stack<int> s;
    s.push(1);
    s.push(2);
    cout<<s.top()<<endl;
    cout<<s.size()<<endl;
    cout<<s.empty()<<endl;
    s.pop();
    cout<<s.top()<<endl;
    return 0;
}

queue

一种容器型适配器,满足先进先出的原则.

#include<bits/stdc++.h>
using namespace std;
int main(){
    queue<int> que;
    que.push(10);
    que.push(20);
    que.push(30);
    cout<<que.front()<<endl;
    cout<<que.back()<<endl;
    cout<<que.size()<<endl;
    que.pop();
    cout<<que.front()<<endl;
    cout<<que.back()<<endl;
    cout<<que.empty()<<endl;
    return 0;
}

priority_queue

queue的一种升级版,也是容器型适配器,是大顶堆,只能通过top访问队列开头的元素.

#include<bits/stdc++.h>
using namespace std;
int main(){
    priority_queue<int> pq;
    pq.push(10);
    pq.push(20);
    pq.push(30);
    cout<<pq.top()<<endl;
    cout<<pq.size()<<endl;
    pq.pop();
    cout<<pq.top()<<endl;
    cout<<pq.empty()<<endl;
    return 0;
}

vector

#include<bits/stdc++.h>
using namespace std;
int main(){
    vector<int> vec;
    vec.push_back(10);
    vec.push_back(20);
    vec.push_back(30);
    vec.pop_back();
    cout<<vec.size()<<endl;
    cout<<vec.empty()<<endl;
    vec.insert(vec.begin()+1, 15);
    vec.erase(vec.begin()+1);
    cout<<vec.at(1)<<endl;
    cout<<vec.front()<<endl;
    cout<<vec.back()<<endl;
    cout<<*vec.begin()<<endl;
    cout<<*vec.rbegin()<<endl;
    return 0;
}

deque

deque是一个双向队列,和普通的queue相比优势在于可索引使用.由于deque是一个容器,因此可以初始化大小,如deque<int> dq(10,10).

#include<bits/stdc++.h>
using   namespace std;
int main(){
    deque<int> dq;
    dq.push_back(1);
    dq.push_back(2);
    dq.push_front(3);
    for(int i=0;i<dq.size();i++){
        cout<<dq.at(i)<<" ";
    }
    cout<<endl;
    cout<<dq.front()<<endl;
    cout<<dq.back()<<endl;
    dq.pop_back();
    dq.pop_front();
    cout<<dq.size()<<endl;
    return 0;
}

map

普通的map是通过红黑树来维护的,因此满足从大到小排序这一特点.可以索引使用,就可以迭代器遍历.

#include<bits/stdc++.h>
using namespace std;
int  main(){
    map<int, int> m;
    m[1] = 2;
    m[2] = 3;
    m[3] = 4;
    m.insert(pair{4, 5});
    m.erase(2);
    auto it = m.find(3);
    if(it!=m.end()){
        cout<<it->first<<" "<<it->second<<endl;
    }
    cout<<m.size()<<endl;
    cout<<m.empty()<<endl;
    for(auto it = m.begin(); it!=m.end(); it++){
        cout<<it->first<<" "<<it->second<<endl;
    }
    return 0;
}

multimap

multimap也是通过红黑树来维护的,但是不同之处在于允许键的重复.使用方法和map没有区别,不单独记录

unordered_map

unordered_map是一种无序的容器,通过哈希表来维护.使用方法没什么区别,不单独记录.

unordered_multimap

unordered_multimap也是一种无序的容器,通过哈希表维护,允许键的重复.由于使用方法,没什么区别,因此不单独记录

set,multiset,unordered_set,unordered_multiset

他们的用法和对应的map并没有区别,只不过map中存的是键值对,而set中存的是一个值

stl算法

find算法

find算法可以应用于vector,deque和普通的array

#include <bits/stdc++.h>
using namespace std;
int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    auto it = std::find(v.begin(), v.end(), 3);
    if (it != v.end()) {
        std::cout << "Found "<< '\n';
    } else {
        std::cout << "Not found\n";
    }
    return 0;
}

reverse算法

reverse算法可以应用于vector,deque和普通的array以及string.

#include <bits/stdc++.h>
using namespace std;
int main() {
    std::string s = "Hello, World!";
    std::reverse(s.begin(), s.end());
    std::cout << s;
    return 0;
}

sort算法

sort算法默认是从小到大进行排序,但是也支持自定义的排序算法.适用于vector,deque和array

#include<bits/stdc++.h>
using namespace std;
bool cmp(int a,int b){
    return -a>-b;
}
int main(){
    std::vector<int> v = {5, 3, 1, 4, 2};
    std::sort(v.begin(), v.end());
    sort(v.begin(), v.end(),greater<int>());
    sort(v.begin(), v.end(),cmp);
    for(auto i:v){
        cout<<i<<" ";
    }
    return 0;
}

max_element与min_element算法

max_element于min_element算法支持vector,deque和array以外,还支持map和set的使用.

#include<bits/stdc++.h> 
using namespace std;
int main(){
    set<int> s;
    s.insert(1);
    s.insert(2);
    s.insert(3);
    auto it=max_element(s.begin(), s.end());
    cout<<*it<<endl;
    return 0;
}

lower_bound和upper_bound算法

是一种二分查找算法.lower_bound返回这个或后一个元素的迭代器,upper_bound返回后一个元素的迭代器

#include<bits/stdc++.h>
using namespace std;
bool cmp(int i,int j){
    return i>j;
}
int main(){
    vector<int> box={1,2,3,4,5,7};
    cout<<*lower_bound(box.begin(),box.end(),3)<<endl;//3
    cout<<*upper_bound(box.begin(),box.end(),3)<<endl;//4
    sort(box.begin(),box.end(),cmp);
    //reverse(box.begin(),box.end());
    cout<<*lower_bound(box.begin(),box.end(),3,greater<int>())<<endl;//3
    cout<<*upper_bound(box.begin(),box.end(),3,greater<int>())<<endl;//2
    return 0;
}

那么有没有什么办法能在翻转向量前去输出这个2呢?

cout<<*(lower_bound(box.begin(),box.end(),3)-1)<<endl;

答案就是找到我们要找的元素,然后将迭代器去减一
注意:在实际做题中,不要直接用*去输出迭代器,而是要判断一下it!=box.end()

accumulate算法

统计容器中元素的值的和.适用于vector,deque,array,set,map.注意的是map统计的是键值对的和都算进去.

#include<bits/stdc++.h>
using namespace std;
int main() {
    vector<int> v = {1, 2, 3, 4, 5};
    int sum = accumulate(v.begin(), v.end(), 0);
    cout << "Sum: " << sum << endl;
    return 0;
}