准备2023（2024）蓝桥杯
前缀和
一维前缀和
s[i]=s[i-1]+a[i]
二维前缀和（子矩阵的和）
s[i][j]=s[i-1][j]+s[i][j-1]-s[i-1][j-1]+a[i][j]
差分
一维数组
//b是差分数组
b[i]+=c;
b[j+1]-=c;
例题
#include二维差分（差分矩阵）
b[x1][y1]+=c;
b[x2+1][y1]-=c;
b[x1][y2+1]-=c;
b[x2+1][y2+1]+=c;
例题：
#include字符串的操作STL
#include字符串
#include 
模拟
模拟题可难也可简单，重点是 读懂题意，抽象出来模型（我这说的好像是废话 ）
例题（简单）
#include 闰年的判断
bool is_leap(int n)
{
if((n%4==0&&n%100!=0)||(n%400==0))
{
return true;
}
return false;
}
高精度
高精度加法
例题
#include 高精度乘法
高精度乘低精度
例题
#include 高精度乘高精度
例题
#include 数学知识
卡特兰数
C0 = 1,
C1 = 1, C2 = 2, C3 = 5, C4 = 14, C5 = 42,
C6 = 132, C7 = 429, C8 = 1430, C9 = 4862, C10 = 16796,
C11 = 58786, C12 = 208012, C13 = 742900, C14 = 2674440, C15 = 9694845,
C16 = 35357670, C17 = 129644790, C18 = 477638700, C19 = 1767263190, C20 = 6564120420, ...
递推公式
#include 
相关题目练习可以参考这位大佬的总结
组合数学
例题
#include例题
#include
if(c[i][j]%k==0)
{
ans++;
}
}
}
cout<<ans<<endl;
ans=0;
}
return 0;
}
素数筛（欧拉筛）
bool st[N];//st[i]为1，说明被筛掉了，也就是说，不是素数
int cnt=0;
for(int i=2;i<=n;i++)
{
if(!st[i])
{
primes[cnt++]=i;
for(int j=i+i;j<=n;j+=i)
{
st[j]=1;
}
}
}
例题
#include 线性筛
int primes[N], cnt; // primes[]存储所有素数
bool st[N]; // st[x]存储x是否被筛掉
void get_primes(int n)
{
for (int i = 2; i <= n; i ++ )
{
if (!st[i]) primes[cnt ++ ] = i;
for (int j = 0; primes[j] <= n / i; j ++ )
{
st[primes[j] * i] = true;
if (i % primes[j] == 0) break;
}
}
质因子分解
定理：一个合数可以由多个比他小的质数相乘而得，而这些质数就是他的质因数。
//要计算的是从1到n之间的所有合数的质因数
for(int i=1;i<=n;i++)
{
int x=i;
if(!st[x])//没有被筛掉，也就是是合数
{
continue;
}
else
{
for(int j=2;j<=x;j++)
{
while(x%j==0)
{
p[cnt++]=j;//p数组中存的是质因数
x=x/j;
}
}
}
}
用map实现
例题
#include约数个数定理
套用上面map实现的代码
void fen(int n)
{
map<int,int> m;
for(int i=2;i<=n/i;i++)
{
if(n%i==0)
{
int c=0;
while(n%i==0)
{
c++;
n=n/i;
}
m[i]+=c;
}
}
if(n>=2)//加上大于根号n的素因子
{
m[n]++;
}
map<int,int>::iterator iter;
for(iter=m.begin();iter!=m.end();iter++)
{
//printf("%d %d\n",iter->first,iter->second);
res*=(iter->second+1);//这里
}
cout<<endl;
}
分离整数
while(n)
{
a.push_back(n%10);//依次存储的是个位 十位等
n=n/10;
}
例题
得到各个位数
//前三位
int n=1234567;
int x=n/10000;
//取后两位
int y=n%100;
进制转换
#include最大公约数
int gcd(int a,int b)
{
return b==0?a:gcd(b,a%b);
}
例题
这个例题中，主要是字符串的操作，最大公约数只是其中的一个应用，但是如果不会最大公约数和最小公倍数的话，也会很麻烦
#include
}
if(b<0)
{
a=-a;
b=-b;
}
if(b==1)
printf("%d\n",a);
else
printf("%d/%d\n",a,b);
return 0;
}
快速幂运算
例题
ps:十年OI一场空，不开long long见祖宗
附上数据范围
#include 贪心算法
取当前情况最好的，贪心不贪，重点在于排序加模拟。
例题
思路：等待时间最小，就是让接水时间最短的人先接。用sort排个序，因为是要输出排队的序号，所以就用pair了
#include 例题
思路：贪心就是取当前情况最好的。在这道题中，正向遍历，如果两者之和大于x,就吃掉a[i]中的，如果a[i]为0了，就吃掉a[i-1]中的糖果。因为后面还有，如果先吃掉a[i-1]中的，对后面没啥影响，所以不是最好的情况。（至于理论证明为啥这样最好，本蒟蒻不会5555）
#include 例题：
思路：这道题的标签是动态规划，但是数据范围有点大，而且俺也不会完全背包问题，及啥滚动数组，就用贪心做了，but只有90分。哭辽
#include 动态规划
格式化输出
//在C++中，cout<<int(2.56);输出就是2，只保留整数部分，如果要四舍五入，就要加上0.5
//可以用printf("%.2lf",2.56);自动进行四舍五入。此外，printf("%02d",6);表示输出占两位，不足两位添加前导0
STL
贴个大佬总结的STL食用指南
//自定义排序方式
bool cmp(int x,int y)
{
return x>y;
}//表示按照从大到小的方式进行。这种定义方式，在pair或者结构体中使用范围更广
//例如
bool cmp(pair<int,int>x,pair<int,int>y)
{
return x.first > y.first;
}//按照first的值升序排列；
//需要包含在头文件algorithm中
sort(a,a+n,cmp);//a为普通数组
sort(a,a+n,greater<int>());//降序，默认是升序
sort(a.begin(),a.end());//a为vector数组
reverse函数
用法示例（vector和数组）
#include 
去重（要求序列是有序的，首先用sort排序）
v.erase(unique(v.begin(),v.end()),v.end());
优先队列
priority_queue<Type, Container, Functional>
set
map
桶计数是map一个功能之一
#include二分查找
binary_search（起始地址，结束地址，要查找的数值）
返回值是 是否存在这么一个数，是一个bool值。
binary_search(a,a+n,3);
lower_bound（起始地址，结束地址，要查找的数值），返回值就是返回第一次出现大于等于那个要查找的数的地址；如果不存在则返回a.end()
lower_bound(a,a+n,3)-a;
upper_bound（起始地址，结束地址，要查找的数值）返回的是被查序列中第一个大于查找的数的指针；,如果不存在则返回a.end()
upper_bound(a,a+n,3)-a;
综合应用
查询某个元素出现的次数
upper_bound - lower_bound
upper_bound(a,a+n,3)-lower_bound(a,a+n,3);
例题
#include
ans+=(upper_bound(a+1,a+n+1,a[i]+c))-(lower_bound(a+1,a+1+n,a[i]+c));
}
cout<<ans<<endl;
return 0;
}
例题
#include 动态规划
考虑小规模。思考的时候，是由n-1推n,由n-2推n-1;写方程的时候，从1推2，推n
搜索bfs
使用队列，queue
例题
思路：本来想用最短路算法，迪杰斯特拉，看到题目标签是bfs，就用了bfs，我是菜鸡，呜呜。这题用pair正好。
#include dfs
搞清楚状态转移
全排列问题
//头文件algorithm
int a[4]={1,2,3,4};
do
{
for(int i=0;i<4;i++)
{
cout<<a[i]<<' ';
}
cout<<endl;
}while(next_permutation(a,a+4));
图的基本应用
邻接表（用vector实现）
#include
cout<<endl;
}
return 0;
}
单源最短路径
迪杰斯特拉算法
例题同下（这个算法不是靠队列实现的）
依然只有60分，因为我用的还是邻接矩阵
#include spfa算法：可以判断是否会存在负权边
例题
邻接矩阵版本（会MLE,只有60分）
#include
}
}
}
}
}
}
int main()
{
cin>>n>>m>>s;
int a,b,w;
memset(dis,INF,sizeof(dis));
memset(mp,INF,sizeof(mp));
for(int i=1;i<=m;i++)
{
cin>>a>>b>>w;
mp[a][b]=min(mp[a][b],w);
}
spfa(s);
for(int i=1;i<=n;i++)
{
cout<<dis[i]<<' ';
}
}
邻接表版
并查集
例题
无路径压缩版本
（会TLE）
#include 路径压缩版
#include 一些注意事项
1.要记得 long long;
2.实现估算一下，如果循环次数超过10e8就要考虑进行优化，否则可能会TLE;
3.二维数组如果大于10e5可能会MLE,要考虑优化；
4.x%n的值为0到n-1；
5.EOF可以用不？
准备了近一个月。
尽人事，听天命吧。
事实证明，会这些基本的算法是不配参加蓝桥杯的 （赛后补充）
含泪捐了300元
附大佬总结的2016年真题