Acwing 蓝桥备战第五天（常用算法模板）

最新推荐文章于 2024-05-24 13:33:25 发布
最新推荐文章于 2024-05-24 13:33:25 发布
阅读量619 收藏 4
点赞数
分类专栏： 算法 文章标签： 蓝桥杯 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxiaodi/article/details/123959384
版权

注意：
本文章只对蓝桥杯可能用到的算法模板，借助算法基础课的内容进行简单整理，不涉及算法原理及推导证明。

快速排序

#include<bits/stdc++.h>
using namespace std;
const int N=100010;
int a[N];
int n;
void quick_sort(int a[],int l,int r){
    if(l>=r) return; //递归出口
    int i=l-1,j=r+1;
    int x=a[(l+r)/2];
    while(i<j){
        do i++; while(a[i]<x);
        do j--; while(a[j]>x);
        if(i<j) swap(a[i],a[j]);
    }
    quick_sort(a,l,j);
    quick_sort(a,j+1,r);
}
int main(){
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d",&a[i]);
    quick_sort(a,0,n-1);
    for(int i=0;i<n;i++) printf("%d ",a[i]);
    return 0;
}

归并排序

#include<iostream>
using namespace std;
const int N=100010;
int a[N],tmp[N];
int n;
void merge_sort(int a[],int l,int r){
    if(l>=r) return;
    int mid=(l+r)/2;
    merge_sort(a,l,mid),merge_sort(a,mid+1,r);
    int i=l,j=mid+1,k=0;
    while(i<=mid&&j<=r){
        if(a[i]<a[j]) tmp[k++]=a[i++];
        else tmp[k++]=a[j++];
    }
    while(i<=mid) tmp[k++]=a[i++];
    while(j<=r) tmp[k++]=a[j++];
    for(int i=l,j=0;i<=r;i++,j++) a[i]=tmp[j];
}
int main(){
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d",&a[i]);
    merge_sort(a,0,n-1);
    for(int i=0;i<n;i++) printf("%d ",a[i]);
    return 0;
}

整数二分（数的范围）

#include<iostream>
using namespace std;
const int N=100010;
int a[N];
int n,q,k;
int main(){
    scanf("%d%d",&n,&q);
    for(int i=0;i<n;i++) scanf("%d",&a[i]);
    while(q--){
        int x;
        scanf("%d",&x);
        int l=0,r=n-1;
        while(l<r){
            int mid=(l+r)/2;
            if(a[mid]>=x) r=mid;
            else l=mid+1;
        }
        if(a[l]!=x) printf("-1 ");
        else printf("%d ",l);
        l=0,r=n-1;
        while(l<r){
            int mid=(l+r+1)/2;
            if(a[mid]<=x) l=mid;
            else r=mid-1;
        }
        if(a[l]!=x) printf("-1\n");
        else printf("%d\n",l);
    }
    return 0;
}

一维前缀和

#include<iostream>
using namespace std;
const int N=100010;
int s[N];
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d",&s[i]);
    for(int i=1;i<=n;i++) s[i]+=s[i-1];
    
    while(m--){
        int l,r;
        scanf("%d%d",&l,&r);
        printf("%d\n",s[r]-s[l-1]);
    }
    
    return 0;
}

二维前缀和（借助画图分析）

#include<iostream>
using namespace std;
const int N=1010;
int a[N][N];
int s[N][N];
int n,m,q;
int main(){
    scanf("%d%d%d",&n,&m,&q);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            scanf("%d",&a[i][j]);
        }
    }
    
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            s[i][j]=s[i-1][j]+s[i][j-1]-s[i-1][j-1]+a[i][j];
        }
    }
    
    while(q--){
        int x1,y1,x2,y2;
        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        printf("%d\n",s[x2][y2]-s[x1-1][y2]-s[x2][y1-1]+s[x1-1][y1-1]);
    }
}

一维差分

#include<iostream>
using namespace std;
const int N=100010;
int a[N],b[N];
int n,m;
void insert(int l,int r,int c){
    b[l]+=c;
    b[r+1]-=c;
}
int main(){
    scanf("%d%d",&n,&m);
    
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        insert(i,i,a[i]);
    }
    
    while(m--){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        insert(a,b,c);
    }
    
    for(int i=1;i<=n;i++) a[i]=a[i-1]+b[i];
    
    for(int i=1;i<=n;i++) printf("%d ",a[i]);
    return 0;
}

差分矩阵(重点复习)

#include<iostream>
using namespace std;
const int N=1010;
int a[N][N],b[N][N];
int n,m,q;
void insert(int x1,int y1,int x2,int y2,int c){
    b[x1][y1]+=c;
    b[x1][y2+1]-=c;
    b[x2+1][y1]-=c;
    b[x2+1][y2+1]+=c;
}
int main(){
    scanf("%d%d%d",&n,&m,&q);
    
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            scanf("%d",&a[i][j]);
            insert(i,j,i,j,a[i][j]);
        }
    }
    
    while(q--){
        int x1,y1,x2,y2,c;
        scanf("%d%d%d%d%d",&x1,&y1,&x2,&y2,&c);
        insert(x1,y1,x2,y2,c);
    }
    
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            b[i][j]+=b[i-1][j]+b[i][j-1]-b[i-1][j-1];
        }
    }
    
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            printf("%d ",b[i][j]);
        }
        printf("\n");
    }
    return 0;
}

单调栈

#include<iostream>
#include<stack>
using namespace std;
stack<int> stk;
int n;
int main(){
    cin>>n;
    for(int i=0;i<n;i++){
        int x;
        cin>>x;
        while(!stk.empty()&&stk.top()>=x) stk.pop();
        if(stk.empty()) printf("-1 ");
        else printf("%d ",stk.top());
        stk.push(x);
    }
    return 0;
}

滑动窗口

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
int a[N];
int n,k;
deque<int> q;
int main(){
    scanf("%d%d",&n,&k);
    
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    
    for(int i=1;i<=n;i++){
        while(q.size()&&q.back()>a[i]) q.pop_back();
        q.push_back(a[i]);
        if(i-k>=1&&a[i-k]==q.front()){
            q.pop_front();
        }
        if(i>=k){
            cout<<q.front()<<" ";
        }
    }
    
    q.clear();
    cout<<endl;
    
    for(int i=1;i<=n;i++){
        while(q.size()&&q.back()<a[i]) q.pop_back();
        q.push_back(a[i]);
        if(i-k>=1&&a[i-k]==q.front()){
            q.pop_front();
        }
        if(i>=k){
            cout<<q.front()<<" ";
        }
    }
    return 0;
}

朴素KMP

#include<iostream>
using namespace std;
const int N=1e5+10;
const int M=1e6+10;
char p[N],s[M];
int n,m;
int ne[N];
int main(){
    cin>>n>>(p+1)>>m>>(s+1);
    for(int i=2,j=0;i<=n;i++){
        while(j&&p[i]!=p[j+1]) j=ne[j];
        if(p[i]==p[j+1]) j++;
        ne[i]=j;
    }
    for(int i=1,j=0;i<=m;i++){
        while(j&&s[i]!=p[j+1]) j=ne[j];
        if(s[i]==p[j+1]) j++;
        if(j==n){
            printf("%d ",i-n);
        }
    }
    
    return 0;
}

KMP求周期

#include<bits/stdc++.h>
using namespace std;
//s长度为n，s存在最小循环节，最小循环节的长度 n-ne[n]，如果存在周期，T=n/(n-ne[n]) 
const int N=1e6+10;
char p[N];
int ne[N];
int main(){
	while(1){
		cin>>(p+1);
		if(p[1]=='.') break;
		int n=strlen(p+1);
		for(int i=2,j=0;i<=n;i++){
			while(j&&p[i]!=p[j+1]) j=ne[j];
			if(p[i]==p[j+1]) j++;
			ne[i]=j;
		}
		if(n%(n-ne[n])==0) printf("%d\n",n/(n-ne[n]));
		else printf("1\n");
	}
	return 0;
}

并查集

#include<iostream>
using namespace std;
const int N=1e5+10;
int p[N];
int n,m;
int find(int x){
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) p[i]=i; //初始化，开始之前每个结点指向自己
    
    while(m--){
        string s;
        int a,b;
        cin>>s;
        if(s=="M"){
            cin>>a>>b;
            a=find(a),b=find(b);
            if(a!=b){
                p[a]=b;
                //a的祖先结点不等于b的祖先结点，两者不在一个集合，让a的祖先结点的父节点指向b的祖先
            }
        }else{
            cin>>a>>b;
            a=find(a),b=find(b);
            if(a==b){
                printf("Yes\n");
            }else{
                printf("No\n");
            }
        }
    }
    return 0;
}

BFS

#include<bits/stdc++.h>
using namespace std;
const int N=110;
int g[N][N];
int dis[N][N];
typedef pair<int,int> PII;
#define x first
#define y second
int n,m;
int bfs(PII start,PII end){
    memset(dis,-1,sizeof dis);
    queue<PII> q;
    dis[start.x][start.y]=0;
    q.push(start);
    while(q.size()){
        auto a=q.front();
        q.pop();
        int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
        for(int i=0;i<4;i++){
            int x=a.x+dx[i];
            int y=a.y+dy[i];
            if(x<1||x>n||y<1||y>m) continue; //越界
            if(g[x][y]==1) continue; //障碍
            if(dis[x][y]!=-1) continue; //已经被扩展
            dis[x][y]=dis[a.x][a.y]+1;
            if(x==n&&y==m) return dis[x][y];
            q.push({x,y});
        }
    }
}
int main(){
    scanf("%d%d",&n,&m);
    
    PII start,end;
    
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            scanf("%d",&g[i][j]);
        }
    }
    
    start={1,1},end={n,m};
    
    int distance=bfs(start,end);
    
    printf("%d",distance);
    return 0;
}

朴素迪杰斯特拉求单源最短路

#include<bits/stdc++.h>
using namespace std;
const int N=510;
int g[N][N];
int dis[N];
bool st[N];
int n,m;
int dijkstra(){
    memset(dis,0x3f,sizeof dis);
    dis[1]=0;
    for(int i=0;i<n-1;i++){
        int t=-1;
        for(int j=1;j<=n;j++){
            if(!st[j]&&(t==-1||dis[t]>dis[j])){
                t=j;
            }
        }
        for(int j=1;j<=n;j++)
        dis[j]=min(dis[j],dis[t]+g[t][j]);
        st[t]=1;
    }
    if(dis[n]==0x3f3f3f3f) return -1;
    else return dis[n];
}
int main(){
    scanf("%d%d",&n,&m);
    memset(g,0x3f,sizeof g);
    while(m--){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        g[a][b]=min(g[a][b],c);
    }
    int distance=dijkstra();
    printf("%d",distance);
    return 0;
}

弗洛伊德求多源最短路

#include<bits/stdc++.h>
using namespace std;
const int N=210;
const int INF=1e9;
int g[N][N];
int n,m,q;
void floyd(){
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                g[i][j]=min(g[i][j],g[i][k]+g[k][j]);
            }
        }
    }
}
int main(){
    scanf("%d%d%d",&n,&m,&q);
    
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(i==j) g[i][j]=0;
            else g[i][j]=INF;
        }
    }
    
    while(m--){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        g[a][b]=min(g[a][b],c);
    }
    
    floyd();
    
    while(q--){
        int a,b;
        scanf("%d%d",&a,&b);
        if(g[a][b]>INF/2) printf("impossible\n");
        else printf("%d\n",g[a][b]);
    }
    return 0;
}

prim求最小生成树

#include<bits/stdc++.h>
using namespace std;
const int N=510;
const int INF=0x3f3f3f3f;
int g[N][N];
int dis[N];
bool st[N];
int n,m;
int prime(){
    memset(dis,0x3f,sizeof dis);
    int ans=0;
    for(int i=0;i<n;i++){
        int t=-1;
        for(int j=1;j<=n;j++){
            if(!st[j]&&(t==-1||dis[t]>dis[j])){
                t=j;
            }
        }
        if(i&&dis[t]==INF) return INF;
        if(i) ans+=dis[t];
        st[t]=1;
        for(int j=1;j<=n;j++){
            dis[j]=min(dis[j],g[t][j]);
        }
    }
    return ans;
}
int main(){
    scanf("%d%d",&n,&m);
    memset(g,0x3f,sizeof g);
    while(m--){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        g[a][b]=g[b][a]=min(g[a][b],c);
    }
    int t=prime();
    if(t==INF) printf("impossible\n");
    else printf("%d\n",t);
    return 0;
}

Kruskal算法求最小生成树

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int p[3*N];
struct Edge{
    int a,b,w;
}edge[2*N];
int n,m;
bool cmp(Edge c,Edge d){
    return c.w<d.w;
}
int find(int x){
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
int main(){
    scanf("%d%d",&n,&m);
    
    for(int i=0;i<m;i++){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        edge[i]={a,b,c};
    }
    
    for(int i=1;i<=n;i++) p[i]=i;
    sort(edge,edge+m,cmp);
    
    int ans=0,cnt=0;
    for(int i=0;i<m;i++){
        int a=edge[i].a,b=edge[i].b,w=edge[i].w;
        a=find(a),b=find(b);
        if(a!=b){
            p[a]=b;
            ans+=w;
            cnt++;
        }
    }
    if(cnt<n-1) printf("impossible\n");
    else printf("%d",ans);
    return 0;
}

声明：
所有模板借鉴于yxc算法基础课，仅供自己复习蓝桥使用。

Acwing基础算法模板
qq_2604939074的博客
01-16 1114
文章目录第一章 基础算法排序快速排序归并排序二分整数二分浮点数二分高精度高精度加法高精度减法前缀和差分双指针前缀和差分位运算离散化区间合并 第一章 基础算法 排序 快速排序 算法模板： void quick_sort(int q[], int l, int r) { if (l >= r) { return; } int i = l - 1, j = r + 1, x = q[(l + r) / 2]; while (i < j) { do { i++; } whi
基础算法模板(Acwing)
Allen的博客
01-27 1307
1.快速排序（Acwing 785.快速排序） void quick_sort(int a[],int l,int r) { if(l>=r)return; int i=l-1,j=r+1,x=l+r>>1;//'+'的优先级高于'>>'移位运算符 while(i<j) { do i++;while(a[i]<x); do ...
ACWing算法模板
qq_44723773的博客
03-03 561
ACWing算法模板 快速排序算法 void quick_sort(int q[], int l, int r) { if (l >= r) return;//区间没有数字，或者只有一个数字，就不需要再进行排序 //x取左右两边边界值，可能会造成超时，故取中间值更优 //i,j指针指向两个边界的两侧 int i = l - 1, j = r + 1, x = q[l + r >> 1]; while (i < j) {
【模板】ACwing算法基础课模板小全
Zh0uKal1的博客
03-30 2984
边界问题因为边界问题只有这两种组合，不能随意搭配 归并排序算法模板 整数二分算法模板 浮点数二分算法模板 高精度加法 高精度减法 高精度乘低精度 高精度乘高精度 高精度除低精度 一维前缀和 前缀和可以用于快速计算一个序列的区间和，也有很多问题里不是直接用前缀和，但是借用了前缀和的思想。 应用 二维前缀和 应用 一维差分 差分是前缀和的逆运算，对于一个数组a，其差分数组b的每一项都是a [ i ]和前一项a [ i − 1 ]的差。注意：差分数组和原数组必须分开存放！！！！ 应用 二维差
acwing算法基础 模板
weixin_47741017的博客
07-17 717
快排： 经典快排 #include<bits/stdc++.h> using namespace std; const int N=1e6+10; int q[N]={}; //核心 void quick_sort(int q[],int l,int r){ if(l>=r) return ; int x=q[(l+r)/2],i=l-1,j=r+1; while(i<j){ do i++;while(q[i]<x);
蓝桥杯Python组算法模板大全
04-04
在本节中，我们将针对蓝桥杯...最后，所有这些算法模板和基础题型都来源于蓝桥云课，这是一个非常适合新手练手的平台。通过熟记这些模板，配合实际编码练习，可以有效地提升解题能力，在实际比赛中获得更好的成绩。
LanQiao:半个月备战蓝桥的做题记录也作为自己正式学算法的起点
04-05
"LanQiao:半个月备战蓝桥的做题记录也作为自己正式学算法的起点"这个标题揭示了作者在短时间内集中精力提升算法技能的决心。在这半个月的准备过程中，通过解决蓝桥平台上的题目，不仅可以积累实战经验，还能对算法有...
蓝桥杯Java 算法模板题+真题训练
04-08
【蓝桥杯Java算法模板题+真题训练】是一系列针对Java编程者设计的算法练习题目，涵盖了排序、动态规划、广度搜索、深度搜索、并查集等基础算法，旨在帮助参赛者提升算法能力，适应蓝桥杯比赛的要求。这些题目来源于...
ACM算法与竞赛基地：蓝桥备战 --- 二分篇
m0_52186223的博客
03-28 600
ACM基地：蓝桥备战 — 二分篇 什么是二分？ ​ 二分是一种搜索策略，类似于高速中学到的梯度下降法，当我们落在某一点是沿着该点斜率，我们可以像最优处移动，二分也是样的策略，但其更加严格，现代算法，如模拟退火，蚁群算法，BP算法针对的都是存在多种最优解，解决的问题也更加宽泛，而作为传统算法的二分，有着更加严格的限制，想要理解二分，必须要对该限制有深刻理解。 接下来我们将展开对二分的学习 二分查找+二分答案 key 1:什么时候能够使用二分 分析几道例题的可二分性 conduit Packing 洛谷题
【思特奇杯·云上蓝桥-算法集训营】第1周蓝桥第一次作业.rar
01-08
【思特奇杯·云上蓝桥-算法集训营】第1周蓝桥第一次作业 这个压缩包文件“【思特奇杯·云上蓝桥-算法集训营】第1周蓝桥第一次作业.rar”是针对"思特奇杯"和"云上蓝桥"算法集训营的参赛者们提供的第一周作业。蓝桥杯...
acwing基础算法模板整理
02-27
算法整理，包括但不限于基础算法，数据结构，搜索图论以及数学知识
蓝桥杯比赛模板-标准模板
03-11
蓝桥杯单片机设计与开发————蓝桥杯省赛、国赛通用比赛标准模板
acwing算法模板
ffkklffffg的博客
04-07 262
2.归并排序 3.二分 4.前缀和 5.差分 6.二进制中1的个数 7.单链表 8.双链表 9.模拟栈 10.模拟队列 11.单调栈 12.滑动窗口 12.kmp字符串 13.Trie字符串统计 14.最大异或对 15.并查集 16.堆 17.哈希表
Acwing排序算法模板
qq_45417626的博客
10-26 694
【自用代码模板】；【代码】Acwing算法模板；Acwing算法基础课；排序；查找；
Acwing 算法基础课 c++模板整理（附python语法基础题）
zombotany的博客
11-26 1319
第kkk个数 归并排序 逆序对数 数的范围 三次方根 高精加 高精减 高精乘 高精除 前缀和 矩阵前缀和 差分 差分矩阵 最长连续不重复子序列 数组元素的目标和 二进制中1的个数 区间和离散化 区间合并 数据结构 单调栈 给定一个长度为 NNN的整数数列，输出每个数左边第一个比它小的数，如果不存在则输出 −1。 滑动窗口 你的任务是确定滑动窗口位于每个位置时，窗口中的最大值和最小值。 KMP Trie 最大异或对 并查集 连通块中点的数量 堆排序 模拟堆 维护
Acwing算法模板分析
最新发布
m0_74293655的博客
05-24 314
基础算法3 01：12：31 离散化往后内容未看。未看：二维差分 797.差分矩阵 基础算法二。799.最长不重复连续子序列。一般用来求解开方后的结果。求某一段区间内所有数的和。差分可看作前缀和的逆运算。
AcWing算法基础的一些模板
qq_34348564的博客
05-26 743
快速排序模板 void quick_sort(int q[],int l,int r){ if(l >= r) return; int i = l-1,j = r+1,,x = q[l+r>>1]; while(i < j){ do i++;while(q[i] < x); do j--;while(q[j] > x); if(i < j) swap(q[i],q[j]); } quick_sort(q,l,j);quick_sort(q,j+
AcWing算法基础课——简单算法模板
Beau_Will的博客
03-09 644
本篇文章只给出代码模板，以及自己对该模板的理解。如果想看正确的算法思路，可以移步AcWing官网看详情。如有理解错误，欢迎大家批评指正。
算法与数据结构模版（AcWing算法基础课笔记，持续更新中）
emmmnmm的博客
04-06 2026
AcWing算法基础课笔记 第一章 基础算法 包括排序、二分、高精度、前缀和与差分、双指针算法、位运算、离散化、区间合并 1. 排序 快速排序： 思路：基于分治思想 确定分界点（取左边界，去中间点，随机取） 调整区间，分<x与>x两部分分别是[l, j]、[j+1, r] 递归左右 void quick_sort(vector<int>&q, int l, int r) { if (l >= r) return; //注意这里是>= int
蓝桥杯Python算法模板集锦：排序、动态规划等
在编程竞赛如蓝桥杯中，熟练掌握各种算法模板是至关重要的，特别是对于使用Python语言的参赛者。以下是一些常见的算法模板，包括排序算法、动态规划、图论、字符串和数论的基础应用。 ### 排序算法 1. **归并排序*...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值