NOIP 信息学 奥赛 考纲 考点 模板 裸题 水题
NOIP 信息学 奥赛 考纲 考点 模板 裸题 水题
部分内容转自：http://blog.csdn.net/txl199106/article/details/71504478
NOIP知识点汇总
加*号是选学，加粗为重点，重要值排序不分先后
-
基础算法
- 贪心、枚举、分治、二分、倍增、*构造、高精、模拟
-
图论
- 图
- 最短路（dijkstra、spfa、floyd），差分约束
- 最小生成树（kruskal、prim）
- 并查集（扩展域）
- 拓扑排序
- 二分图染色，*二分图匹配
- tarjan找scc、桥、割点，缩点
- *分数规划
- 树
- 树上倍增（LCA）
- 树的直径、树的重心
- dfs序
- *树链剖分
- 图
-
数论
- gcd、lcm
- 埃氏筛法
- exgcd，求解同余方程、逆元
- 快速幂
- *组合数学
- 矩阵
-
数据结构
- 链表、队列（单调队列）、栈（单调栈）
- 堆、st表、hash表
- 线段树、树状数组
- 字典树
- *分块
-
动态规划
- 背包DP、树形DP、记忆化搜索、递推
- 区间DP、序列DP
- *DP优化（不涉及斜率优化、四边形不等式等等）
-
搜索
- 暴搜（dfs、bfs）
- 搜索的剪枝
- 启发式搜索（A*）
- 迭代加深搜索、* IDA*
- *随机化搜索
-
其他算法
- STL的基本使用方法
- 脑洞的正确使用方法
- *KMP
- *状态压缩
省选知识点汇总
冲省选的，先把整理的NOIP知识点学扎实，注意一定要学扎实
加粗是重点，星号是选学
学无止境，欢迎大家继续补充~
-
图论
- 网络流（dinic，SAP，ISAP选一个，费用流写EK就行。*zkw费用流），二分图
- 点分治，边分治，*动态点分治
- 树链剖分，动态树，树分块
- 虚树，*prufer编码
- *仙人掌算法
-
数据结构
- 带权并查集
- Splay（作为平衡树和维护区间），Treap，替罪羊树
- 线段树（权值线段树），树状数组，*线段树合并
- 分块，块状链表，*双向链表
- 凸包
- 树套树
- 主席树，可持久化trie，*其它可持久化数据结构
- 莫队算法，*树上莫队，CDQ分治，整体二分
- 二维线段树，*KDtree
- *舞蹈链，*二进制分组，*左偏树，*超哥线段树，*后缀平衡树，*fhqTreap
-
字符串相关算法及数据结构
- hash（自然溢出，双hash）
- kmp，AC自动机，trie
- 后缀数组
- manacher，最小表示法
- *后缀自动机，*回文自动机，*后缀树
-
数学
- 线性筛，积性函数，容斥原理，莫比乌斯反演
- exgcd，费马小定理，Lucas定理，高中排列组合
- 高斯消元，概率与期望相关
- 中国剩余定理，BSGS，欧拉定理
- 矩阵乘法
- 单纯形法解线性规划
- FFT
- 线性代数（行列式）
- *Simpson积分，高中求导与积分
- *群论
- *生成函数， 多项式类算法
- 博弈论相关，*密码学，阶，原根
-
计算几何
- 向量的点积/叉积，计算几何基础
- *二维计算几何相关，*三维计算几何相关
- *半平面交，*旋转卡壳，*三角剖分
-
搜索
- A*，记忆化搜索，迭代深搜，双向广搜
- 模拟退火，爬山算法，*随机增量法
-
动态规划
- 基础DP，树形DP，数位DP，状压DP，期望DP，基环树DP，*插头DP
- 斜率优化，矩乘优化，单调队列优化，倍增优化，*四边形不等式优化
- trie图DP，*仙人掌DP
-
其他算法
- 构造，乱搞，随机化，三分法，打表，启发式合并
- Huffman树，2-sat，*朱刘算法
说真的，计算几何要么全场不会，要么全场AK。所以尽量花时间在别的地方吧。
以下是针对考点提供的裸题，例题，希望能加快读者理解掌握考点。2018-3-16 16:59
NOIP知识点汇总
加*号是选学，加粗为重点，重要值排序不分先后
-
基础算法
- 贪心、枚举、分治、二分、倍增、*构造、高精、模拟
-
图论
- 图
- 最短路（dijkstra、spfa、floyd），
- 差分约束
- //P1645 序列
//差分约束
//样例通过，提交，测试点3,4,6WA
//经过对比，发现，还是左边界的问题。
//提交AC 2018-5-9
#include
#include
struct node{
int to,next,w;
}e[1000+1000*2+100];
int cnt=0,head[1100],d[1100],vis[1100],q[1100*10],R=-1999999999;
int max(int a,int b){
return a>b?a:b;
}
void add_edge(int u,int v,int w){
cnt++,e[cnt].to=v,e[cnt].w=w,e[cnt].next=head[u],head[u]=cnt;//竟然漏了e[cnt].w=w;这句
}
void spfa(int x){
int h,t,i,b,u,v,w;
memset(vis,0,sizeof(vis));
for(i=0;i<=R;i++)d[i]=-1999999999;
h=t=1;
q[t]=x,t++,vis[x]=1,d[x]=0;
while(h
while(b){
v=e[b].to,w=e[b].w;
if(d[v]
if(vis[v]==0){
vis[v]=1;
q[t]=v;
t++;
}
}
b=e[b].next;
}
h++;
}
}
int main(){
int u,v,w,i,n;
memset(head,0,sizeof(head));
scanf("%d",&n);
for(i=1;i<=n;i++){
scanf("%d%d%d",&u,&v,&w);
R=max(R,v),add_edge(u-1,v,w);//此处写成 add_edge(u+1,v+1,w)
}
for(i=0;i<=R;i++)
add_edge(i-1,i,0);
for(i=0;i<=R;i++)
add_edge(i,i-1,-1);
spfa(0);
printf("%d",d[R]);
return 0;
}
试了：随机数据生成与对拍 但发现 该题数据 还想遵循一定规则，故随机数据生成 暂告 搁置 2018-5-10
- 最小生成树（kruskal、prim）
- 并查集（扩展域）
- 拓扑排序
- 二分图染色，*二分图匹配
- tarjan找scc、桥、割点，缩点
- *分数规划
- 树
- 树上倍增（LCA）：
- http://blog.csdn.net/saramanda/article/details/54963914此文介绍得不错，可以作为初步了解，但又一个疑问，适用提交，满二叉树，完全二叉树，还是普通的二叉树。
- https://www.cnblogs.com/yyf0309/p/5972701.html本人偏好此文，有图有程序。
- 树的直径：
- poj2631 求树的直径裸题
- https://www.cnblogs.com/a-clown/p/6131346.html此文介绍得不错
- http://poj.org/problem?id=2631可见该题
- https://vjudge.net/problem/POJ-2631 可见该题
- 带着问题学习，明显效率高了很多，https://www.cnblogs.com/jsawz/p/6809817.html该文有树的直径概念及代码 ，经样例模拟，发现此文树的直径代码有误，起始点疏漏了访问标记，造成多次访问。2018-3-21
-
树上最长的简单路径即为树的直径。
求树的直径的方法就是在树上任选一点u，求距离点u最远的点y，再求距离点y最远的点s，点y到点s的距离即为树的直径。
- //poj 2631 Roads in the North
//树的直径 裸题
//该题没说道路的数量范围,采用C(n,2)
//采用邻接表存储 数据
//样例通过，提交AC 2018-3-18 20:27
//1.树的直径
//树上最长的简单路径即为树的直径。
//求树的直径的方法就是在树上任选一点u，求距离点u最远的点y，再求距离点y最远的点s，点y到点s的距离即为树的直径。2018-3-21 AC
#include
#include
int d[10100],head[10100],cnt=0,vis[10100];//没设置访问标志vis[10100]，造成了理解困难
struct node{
int to,next,w;
}e[10100*10100/2];
int max(int a,int b){
return a>b?a:b;
}
void add_edge(int u,int v,int w){
cnt++,e[cnt].to=v,e[cnt].w=w,e[cnt].next=head[u],head[u]=cnt;
}
void dfs(int x){
int v,b;
b=head[x];
while(b){
v=e[b].to;
if(!vis[v])d[v]=d[x]+e[b].w,vis[v]=1,dfs(v);//此处写成 if(!d[v])d[v]=d[x]+e[b].w,dfs(v);
b=e[b].next;
}
}
int main(){
int u,v,w,n=0,y;
memset(head,0,sizeof(head));
while(scanf("%d%d%d",&u,&v,&w)!=EOF)n=max(max(u,v),n),add_edge(u,v,w),add_edge(v,u,w);//无向图
memset(vis,0,sizeof(vis)),memset(d,0,sizeof(d));
vis[1]=1,dfs(1);//注意vis[1]=1别忘了
for(u=y=1;u<=n;u++)if(d[u]>d[y])y=u;
memset(vis,0,sizeof(vis)),memset(d,0,sizeof(d));
vis[y]=1,dfs(y);//注意vis[y]=1别忘了
for(u=y=1;u<=n;u++)if(d[u]>d[y])y=u;
printf("%d",d[y]);
return 0;
}
- 树的重心
- http://blog.csdn.net/acdreamers/article/details/16905653此文介绍得不错
- https://www.cnblogs.com/jsawz/p/6809817.html此文介绍了树的重心概念
-
若有一点，其所有子树中最大子树的节点数最少，则该点就是这棵树的重心。
一般的树只有一个重心，有些有偶数个节点的树，有两个节点。
求树的重心方法就是随意确定一个根节点，先把无根树转化为有根树，dfs求出所有点的子树的节点个数。如果有一点满足该点的子树的节点数的二倍大于等于总结点数(size[u]*2>=n)，并且该点的儿子都满足子树的节点数的二倍小于等于总结点数(size[son_u]*2<=n)，这个点就是树的重心。
- poj 1655 Balancing Act
- https://vjudge.net/problem/POJ-1655可见该题
- https://www.cnblogs.com/kuangbin/p/3427267.html此文代码写得不错
- http://blog.csdn.net/bigbigship/article/details/47261031此文代码也写得不错
- //poj-1655
//样例通过，提交AC 2018-3-21 17:34
#include
#include
#define maxn 20100
int son[maxn],cnt,head[maxn],vis[maxn],num,n,ans;//此处写成 head[maxn]
struct node{
int to,next;
}e[maxn*2];//此处写成 e[maxn*maxn/2]
void add_edge(int u,int v){//邻接表
cnt++,e[cnt].to=v,e[cnt].next=head[u],head[u]=cnt;
}
int max(int a,int b){
return a>b?a:b;
}
void dfs(int x){
int b,v,maxson=0;//maxson是临时变量，而非全局变量
son[x]=1,b=head[x];
while(b){
v=e[b].to;
if(!vis[v])vis[v]=1,dfs(v),son[x]+=son[v];
maxson=max(maxson,son[v]);
b=e[b].next;
}
maxson=max(maxson,n-son[x]);//此处写成maxson=max(maxson,n-maxson);//最大子树节点数
if(maxson
}
int main(){
int T,i,u,v;
scanf("%d",&T);
while(T--){
memset(head,0,sizeof(head)),memset(vis,0,sizeof(vis)),num=999999999,n,ans=999999999,cnt=0;//漏了cnt=0一直Runtime Error//注意，每次num=999999999,n,ans=999999999都要初始化
scanf("%d",&n);
for(i=1;i<=n-1;i++)scanf("%d%d",&u,&v),add_edge(u,v),add_edge(v,u);//无向图
vis[1]=1,dfs(1);
printf("%d %d\n",ans,num);//此处写在while循环之外，真是昏招
}
return 0;
}
- dfs序
- *树链剖分
- 图
-
数论
- gcd、lcm
- 埃氏筛法
- exgcd，
- //P1516 青蛙的约会
- //https://www.luogu.org/problemnew/show/P1516可提交测评
//0 < L < =2100000000已经接近int的极限，该题考虑用long long
//一段时间的数论学习下来，还是小有成就的，理解力，推导能力大幅度的上了一个台阶，读者若想好好学习，可参看笔者文章
//https://blog.csdn.net/mrcrack/article/details/80352151
//以下为AC代码，一次编写成功。2018-6-18 18:59
#include
#define LL long long
LL gcd(LL a,LL b){
return b?gcd(b,a%b):a;
}
LL exgcd(LL a,LL b,LL *x,LL *y){
LL t,d;
if(b==0){
*x=1,*y=0;
return a;
}
d=exgcd(b,a%b,x,y);
t=*x,*x=*y,*y=t-a/b**y;
return d;
}
int main(){
LL X,Y,M,N,L;
LL a,b,c,d;
LL a0,b0,c0;
LL x0,y0,x1;
scanf("%lld%lld%lld%lld%lld",&X,&Y,&M,&N,&L);
a=((N-M)%L+L)%L,b=L,c=((X-Y)%L+L)%L;
d=gcd(a,b);
if(c%d){
printf("Impossible");
return 0;
}
a0=a/d,b0=b/d,c0=c/d;
exgcd(a0,b0,&x0,&y0);
x0*=c0,y0*=c0;
x1=(x0%b0+b0)%b0;
printf("%lld",x1);
return 0;
}
- //p1516 青蛙的约会
//https://www.luogu.org/problemnew/show/P1516可提交测评
//扩展欧几里得算法
//是否需要考虑，正负数？
//该题，比较简单的就是，输出Impossible,猜测能拿到20分
//考虑了，还是采用long long比int胜算大
//以下为运用了 求解线性同余方程 性质，何时有解，何时无解，提交20分，计算过程中没有顾及负数。满意2018-5-16
//样例通过，提交AC 2018-5-16 17:30 以下为AC 代码
#include
#define LL long long
LL X,Y,M,N,L,a,b,c;
LL gcd(LL a,LL b){
return b?gcd(b,a%b):a;
}
LL exgcd(LL a,LL b,LL *x,LL *y){
LL t,d;
if(b==0){
*x=1,*y=0;//此处写成 *x=c/a
return a;
}
d=exgcd(b,a%b,x,y);
t=*x,*x=*y,*y=t-a/b**y;
return d;
}
int main(){
LL x,y,t,d;
scanf("%lld%lld%lld%lld%lld",&X,&Y,&M,&N,&L);
a=((N-M)%L+L)%L,b=L,c=((X-Y)%L+L)%L;//此处写成 a=N-M,b=L,c=X-Y;
if(c%gcd(a,b)){
printf("Impossible");
return 0;
}
d=exgcd(a,b,&x,&y);
t=b/d;
x=(c/d*x%t+t)%t;//此处写成 x=(c*x%t+t)%t; 只有50分 ,修改，只有70分
printf("%lld",x);
return 0;
}
- //p1516 青蛙的约会
//https://www.luogu.org/problemnew/show/P1516可提交测评
//扩展欧几里得算法
//是否需要考虑，正负数？
//该题，比较简单的就是，输出Impossible,猜测能拿到20分
//考虑了，还是采用long long比int胜算大
//以下为运用了 求解线性同余方程 性质，何时有解，何时无解，提交20分，计算过程中没有顾及负数。满意2018-5-16
#include
#define LL long long
LL X,Y,M,N,L,a,b,c;
LL gcd(LL a,LL b){
return b?gcd(b,a%b):a;
}
int main(){
scanf("%lld%lld%lld%lld%lld",&X,&Y,&M,&N,&L);
a=M-N,b=L,c=Y-X;
if(c%gcd(a,b)){
printf("Impossible");
return 0;
}
return 0;
} - //p1516 青蛙的约会
//https://www.luogu.org/problemnew/show/P1516可提交测评
//扩展欧几里得算法
//是否需要考虑，正负数？
//该题，比较简单的就是，输出Impossible,猜测能拿到20分
//考虑了，还是采用long long比int胜算大
//以下为20分代码，满意 2018-5-16
#include
int main(){
printf("Impossible");
return 0;
} - 求解同余方程、逆元
- 快速幂
- *组合数学
- 矩阵
-
数据结构
- 链表、
- 队列（单调队列）、
-
//P1886 滑动窗口
//在线测评地址https://www.luogu.org/problemnew/show/P1886
//先纯模拟,O(n^2)，估计最多得10分，样例很快通过，提交
//测试点8-10 TLE，还是那句话，数据太水了。2018-12-25
#include
#define maxn 1000100
int a[maxn],b[maxn],c[maxn],b_min,c_max;//b最小值c[最大值
int min(int a,int b){
return a
int max(int a,int b){
return a>b?a:b;
}
int main(){
int n,k,i,j,cnt=0;
scanf("%d%d",&n,&k);
for(i=1;i<=n;i++)
scanf("%d",&a[i]);
for(i=1;i<=n-k+1;i++){
b_min=c_max=a[i];
for(j=i;j<=i+k-1;j++){
b_min=min(b_min,a[j]);
c_max=max(c_max,a[j]);
}
cnt++,b[cnt]=b_min,c[cnt]=c_max;
}
for(i=1;i<=cnt;i++)
printf("%d ",b[i]);
printf("\n");
for(i=1;i<=cnt;i++)
printf("%d ",c[i]);
return 0;
} -
//P1886 滑动窗口
//在线测评地址https://www.luogu.org/problemnew/show/P1886
//AC。2018-12-25
#include
#include
#define maxn 1000100
int q[maxn],a[maxn];//存储序列
int main(){
int n,k,i,h,t;
scanf("%d%d",&n,&k);
for(i=1;i<=n;i++)scanf("%d",&a[i]);
h=t=1,q[t]=1,t++;//此处写成 q[t]=a[1]
for(i=1;i<=n;i++){//此处写成 for(i=1;i<=n-k+1;i++)
while(h
q[t]=i,t++;
while(h
printf("%d ",a[q[h]]);
}
printf("\n");
h=t=1,q[t]=1,t++;//此处写成 q[t]=a[1]
for(i=1;i<=n;i++){//存最大值
while(h
while(h
}
return 0;
} - P1886 滑动窗口
- https://www.luogu.org/problemnew/show/P1886
- //P1886 滑动窗口
//https://www.luogu.org/problemnew/show/P1886可见该题
//https://vjudge.net/problem/POJ-2823可见该题
//读题发现看不懂，仔细看了题中的模拟过程，还是看懂了
//读题，发现该题可以模拟出来，但是会超时
//50%的数据，n<=10^5 100%的数据，n<=10^6
//可以预测 模拟 大约30分
//用模拟代码提交，只有测试点9 TLE 不敢想象啊 2018-3-23 - //P1886 滑动窗口
//提交，测试点1-8,10WA
//仔细一看，样例都没通过，确实看走眼了
//样例通过，提交AC 2018-3-23 21:20
#include
#define maxn 1000100
int a[maxn],q[maxn],h,t;
int main(){
int i,j,n,k;
scanf("%d%d",&n,&k);
for(i=1;i<=n;i++)scanf("%d",&a[i]);
h=t=1;
for(i=1;i<=n;i++){//最小值
while(h
q[t]=i,t++;
while(h
}
printf("\n"),h=t=1;
for(i=1;i<=n;i++){//最大值
while(h
while(h
}
return 0;
}
以下代码为90分 纯枚举算法
- //此文代码写得不错https://www.cnblogs.com/wawcac-blog/p/6986710.html
#include
#define maxn 1000100
#define INF 999999999
int a[maxn],min[maxn],max[maxn];
int main(){
int n,k,i,j,b,c;//b最小 c最大
scanf("%d%d",&n,&k);
for(i=1;i<=n;i++)scanf("%d",&a[i]);
for(i=1;i<=n-k+1;i++){
b=INF,c=-INF;
for(j=i;j<=i+k-1;j++){
if(a[j]
}
min[i]=b,max[i]=c;
}
for(i=1;i<=n-k+1;i++)printf("%d ",min[i]);
printf("\n");
for(i=1;i<=n-k+1;i++)printf("%d ",max[i]);
return 0;
} - //hdu 3530 Subsequence
//https://vjudge.net/problem/HDU-3530可见该题
//单调队列
//看了半天题目，竟然没看懂，看了中文题目，才发现the difference between指的是 差值 而不是 不同
//弄明白题意，开始考虑该题思路
//https://blog.csdn.net/zxf654073270/article/details/42712351此文代码写得不错
//https://blog.csdn.net/dan__ge/article/details/51746590此文代码也写得不错
//提交，Compilation Error，发现要将中文注释删除,将中文注释全部删除后，提交AC 2018-3-24
//故下面代码要想AC，需将中文注释全部删除.
#include
#define maxn 100100
int a[maxn],q1[maxn],q2[maxn],h1,t1,h2,t2,pos;
int max(int a,int b){
return a>b?a:b;
}
int main(){
int n,m,k,i,ans;
while(scanf("%d%d%d",&n,&m,&k)!=EOF){
h1=t1=1,h2=t2=1,pos=0,ans=0;
for(i=1;i<=n;i++)scanf("%d",&a[i]);
for(i=1;i<=n;i++){
while(h1
while(h2
while(h1
if(q1[h1]
if(h1
}
printf("%d\n",ans);
}
return 0;
}
以下代码包含中文注释，无法AC，仅供参考之用 - #include
#define maxn 100100
int a[maxn],q1[maxn],q2[maxn],h1,t1,h2,t2,pos;
int max(int a,int b){
return a>b?a:b;
}
int main(){
int n,m,k,i,ans;
while(scanf("%d%d%d",&n,&m,&k)!=EOF){
h1=t1=1,h2=t2=1,pos=0,ans=0;//请注意pos初始化很重要，pos=0而非1
for(i=1;i<=n;i++)scanf("%d",&a[i]);
for(i=1;i<=n;i++){
while(h1
while(h2
while(h1
if(q1[h1]
if(h1
printf("%d\n",ans);
}
return 0;
}
- 栈（单调栈）
-
//P2866 [USACO06NOV]糟糕的一天Bad Hair Day
//在线测评地址https://www.luogu.org/problemnew/show/P2866
//先试试纯模拟O(n^2)
//(8000+0)*8000/2=6.4*10^9
//个数要采用long long
//样例通过，提交，测试点2,8,10TLE 70分，还算满意，同时说明数据挺水。
//2018-12-26 20:43
#include
#define LL long long
LL cnt=0;
int h[80100];
int main(){
int n,i,j;
scanf("%d",&n);
for(i=1;i<=n;i++)scanf("%d",&h[i]);
for(i=1;i<=n;i++)
for(j=i+1;j<=n;j++)
if(h[i]>h[j])cnt++;
else break;
printf("%lld\n",cnt);
return 0;
} -
//P2866 [USACO06NOV]糟糕的一天Bad Hair Day
//在线测评地址https://www.luogu.org/problemnew/show/P2866
//先试试纯模拟O(n^2)
//(8000+0)*8000/2=6.4*10^9
//个数要采用long long
//样例通过，提交，测试点2,8,10TLE 70分，还算满意，同时说明数据挺水。
//2018-12-26 20:43
//开一个栈，a[i]元素必需置于栈顶，放入之前，top的数值，表示a[i]能被之前的几头牛看见。
//样例通过，提交AC。2018-21-26 21:00
#include
#define LL long long
LL cnt=0;
int h[80100],stack[80100],top=0;
int main(){
int n,i;
scanf("%d",&n);
for(i=1;i<=n;i++){
scanf("%d",&h[i]);
while(top>0&&stack[top]<=h[i])top--;//弹出不能看见a[i]的牛
cnt+=top;
stack[++top]=h[i];
}
printf("%lld\n",cnt);
return 0;
}
- //poj 3250 Bad Hair Day
//https://vjudge.net/problem/POJ-3250可见该题
//首先采用纯模拟
//程序编写比较容易，提交也出现了意料中的Time Limit Exceeded
//这种情况比较常见，需要学习特定算法，单调栈
//https://blog.csdn.net/alongela/article/details/8229702该文思路介绍得不错,思路摘抄如下：
//从左到右依次读取当前牛的高度，从栈顶开始把高度小于或等于当前牛的高度的那些元素删除，此时栈中剩下的元素的数量就是可以看见当前牛的其他牛的数量。把这个数量加在一起，就可以得到最后的答案了。
//仔细想想，这个思路，不通过专门训练，很难想到
//样例通过，提交Wrong Answer
//仔细思考，(80000+0)/2*80000=32*10^8=3.2*10^9 int要溢出，果断改成long long
//提交Wrong Answer
//无奈，https://www.luogu.org/problemnew/show/P2866提交，竟然AC ，没想法啊
//http://codevs.cn/problem/3098/提交，还是AC
//https://vjudge.net/problem/POJ-3250提交，AC，真是奇怪了，代码没改过啊!2018-3-26 20:56
//调出提交的代码，才发现，测试语句未删除,确实有误。2018-3-26 21:00
#include
#define maxn 80100
int a[maxn],n,stack[maxn],top=0;
long long cnt=0;
int main(){
int i;
scanf("%d",&n);
for(i=1;i<=n;i++){
scanf("%d",&a[i]);
while(top>0&&stack[top]<=a[i])top--;//此处写成 while(top>0&&stack[top]
stack[++top]=a[i];
}
printf("%lld",cnt);
return 0;
}
- 堆、
- st表、
- //P3865 【模板】ST表
//https://www.cnblogs.com/Blackops/p/6295094.html此文思路介绍得不错
//样例通过，提交AC 2018-4-11 16:31
#include
int f[100100][25],n,m,a[100100];
int max(int a,int b){
return a>b?a:b;
}
int main(){
int i,j,left,right,k;
scanf("%d%d",&n,&m);
for(i=1;i<=n;i++)scanf("%d",&a[i]),f[i][0]=a[i];
for(j=1;(1<
scanf("%d%d",&left,&right),k=0;
while(1<
return 0;
}
//P2251 质量检测
//st表
//样例通过，提交,全WA
//排查，发现将right=m写成了right=4
//修改，提交AC 2018-4-12
#include
#define maxn 100100
int f[maxn][25],a[maxn];
int min(int a,int b){
return a
int main(){
int n,m,i,j,left,right,k;
scanf("%d%d",&n,&m);
for(i=1;i<=n;i++)scanf("%d",&a[i]),f[i][0]=a[i];
for(j=1;(1<
k=0;
while((1<
}
return 0;
}
- hash表(哈希表)
- 水题 hdu 1128 Self Numbers
- https://vjudge.net/problem/HDU-1128可见该题
- https://blog.csdn.net/laojiu_/article/details/51169445此文代码写得不错
- //hdu 1128 Self Numbers
//看了数据范围less than or equal 1000000至少得采用O(n)算法
//https://blog.csdn.net/laojiu_/article/details/51169445此文代码写得不错
//样例通过，提交AC 2018-3-28 17:20
#include
#include
#define maxn 1000100
int hash[maxn];
int fun(int x){
int sum=0;
while(x)sum+=x%10,x/=10;
return sum;
}
int main(){
int i,t;
memset(hash,0,sizeof(hash));
for(i=1;i<=maxn;i++)t=i,t+=fun(i),hash[t]=1;
for(i=1;i<=maxn-100;i++)
if(!hash[i])
printf("%d\n",i);
return 0;
} - //hdu 1014 Uniform Generator
//https://vjudge.net/problem/HDU-1014可见该题
//哈希表水题
//结合文中例子，看懂该题。
//一直在犹豫，算几次才算结束，
//https://blog.csdn.net/laojiu_/article/details/51165229翻看代码，发现上述问题解决
//总结，多模拟，大胆猜想。
//样例通过，提交AC 2018-3-29
#include
#include
int hash[100100];
int main(){
int step,mod,i,x;
while(scanf("%d%d",&step,&mod)!=EOF){
memset(hash,0,sizeof(hash)),x=0;
for(i=1;i<=mod;i++){
x=(x+step)%mod;
if(!hash[x])hash[x]=1;
else break;
}
if(i==mod+1)printf("%10d%10d Good Choice\n\n",step,mod);
else printf("%10d%10d Bad Choice\n\n",step,mod);
}
return 0;
}
- 线段树、
- //https://www.luogu.org/problemnew/show/P3372
- //洛谷 P3372 【模板】线段树 1
//调了会，样例通过，提交AC 2018-5-8 收获是 对 线段树 理解更深刻了
#include
#include
#define maxn 100100
#define LL long long
LL n,m,lazy[4*maxn],ans,max_k=-999999999;
struct node{
LL left,right,v;
}q[4*maxn];
void build(LL k,LL left,LL right){
LL mid=(left+right)/2;
q[k].left=left,q[k].right=right;
if(q[k].left==q[k].right){
scanf("%lld",&q[k].v);
if(max_k
}
build(2*k,left,mid);
build(2*k+1,mid+1,right);
q[k].v=q[2*k].v+q[2*k+1].v;
}
void down(LL k){
LL v=lazy[k];
//此处多写了此句q[k].v+=(q[k].right-q[k].left+1)*v;
if(2*k<=max_k){//判断有无越界
lazy[2*k]+=v;
q[2*k].v+=(q[2*k].right-q[2*k].left+1)*v;//漏了此句
}
if(2*k+1<=max_k){//判断有无越界
lazy[2*k+1]+=v;
q[2*k+1].v+=(q[2*k+1].right-q[2*k+1].left+1)*v;//漏了此句
}
lazy[k]=0;
}
void query(LL k,LL left,LL right){
LL mid=(q[k].left+q[k].right)/2;//此处写成 LL mid=(left+right)/2;
if(left<=q[k].left&&q[k].right<=right){
ans+=q[k].v;
return ;
}
if(lazy[k])down(k);
if(left<=mid)query(2*k,left,right);
if(right>=mid+1)query(2*k+1,left,right);
}
void add(LL k,LL left,LL right,LL v){
LL mid=(q[k].left+q[k].right)/2;//此处写成 LL mid=(left+right)/2;
if(left<=q[k].left&&q[k].right<=right){
q[k].v+=(q[k].right-q[k].left+1)*v;
lazy[k]+=v;//漏了此句
return ;
}
if(lazy[k])down(k);
if(left<=mid)add(2*k,left,right,v);//此处写成 query(2*k,left,right)昏招
if(right>=mid+1)add(2*k+1,left,right,v);//此处写成 query(2*k+1,left,right)昏招
q[k].v=q[2*k].v+q[2*k+1].v;
}
int main(){
LL i,cmd,x,y,v;
scanf("%lld%lld",&n,&m);
build(1,1,n);
memset(lazy,0,sizeof(lazy));
while(m--){
scanf("%lld",&cmd);
if(cmd==2){
ans=0;
scanf("%lld%lld",&x,&y);
query(1,x,y);
printf("%lld\n",ans);
}else{//cmd==1
scanf("%lld%lld%lld",&x,&y,&v);
add(1,x,y,v);
}
}
return 0;
}
//P3372 【模板】线段树 1
//枚举的方式，猜测70分。
//果然，提交70分，测试点8,9,10 TLE 2018-5-7 18:01
#include
#define maxn 100100
#define LL long long
LL a[maxn];
int main(){
LL n,m,i,j,cmd,x,y,k,sum;
scanf("%lld%lld",&n,&m);
for(i=1;i<=n;i++)scanf("%lld",&a[i]);
while(m--){
scanf("%lld",&cmd);
if(cmd==1){
scanf("%lld%lld%lld",&x,&y,&k);
for(i=x;i<=y;i++)a[i]+=k;
}else{
sum=0;
scanf("%lld%lld",&x,&y);
for(i=x;i<=y;i++)sum+=a[i];
printf("%lld\n",sum);
}
}
return 0;
}
- 树状数组
- 字典树
- *分块
-
动态规划
- 连续最大子段和
-
//P1115 最大子段和
-
//https://www.luogu.org/problemnew/show/P1115可提交测评
//f[i]表示以a[i]结尾的最大子段和
//样例通过，提交AC 2018-4-24 20:38
#include
#define maxn 200100
int a[maxn],f[maxn],MAX;
int max(int a,int b){
return a>b?a:b;
}
int main(){
int i,n;
scanf("%d",&n);
for(i=1;i<=n;i++)scanf("%d",&a[i]);
MAX=f[1]=a[1];
for(i=2;i<=n;i++){//算法的时间复杂度O(n)
f[i]=max(f[i-1]+a[i],a[i]);
MAX=max(MAX,f[i]);
}
printf("%d",MAX);
return 0;
}
- 背包DP、树形DP、记忆化搜索、递推
- 区间DP、序列DP
- *DP优化（不涉及斜率优化、四边形不等式等等）
-
搜索
- 暴搜（dfs、bfs）
- 搜索的剪枝
- 启发式搜索（A*）
- 迭代加深搜索、* IDA*
- *随机化搜索
-
其他算法
- STL的基本使用方法
- 脑洞的正确使用方法
- *KMP
- *状态压缩
省选知识点汇总
冲省选的，先把整理的NOIP知识点学扎实，注意一定要学扎实
加粗是重点，星号是选学
学无止境，欢迎大家继续补充~
-
图论
- 网络流（dinic，SAP，ISAP选一个，费用流写EK就行。*zkw费用流），二分图
- 点分治，边分治，*动态点分治
- 树链剖分，动态树，树分块
- 虚树，*prufer编码
- *仙人掌算法
-
数据结构
- 带权并查集
- Splay（作为平衡树和维护区间），Treap，替罪羊树
- 线段树（权值线段树），树状数组，*线段树合并
- 分块，块状链表，*双向链表
- 凸包
- 树套树
- 主席树，可持久化trie，*其它可持久化数据结构
- 莫队算法，*树上莫队，CDQ分治，整体二分
- 二维线段树，*KDtree
- *舞蹈链，*二进制分组，*左偏树，*超哥线段树，*后缀平衡树，*fhqTreap
-
字符串相关算法及数据结构
- hash（自然溢出，双hash）
- kmp，AC自动机，trie
- 后缀数组
- manacher，最小表示法
- *后缀自动机，*回文自动机，*后缀树
-
数学
- 线性筛，积性函数，容斥原理，莫比乌斯反演
- exgcd，费马小定理，Lucas定理，高中排列组合
- 高斯消元，概率与期望相关
- 中国剩余定理，BSGS，欧拉定理
- 矩阵乘法
- 单纯形法解线性规划
- FFT
- 线性代数（行列式）
- *Simpson积分，高中求导与积分
- *群论
- *生成函数， 多项式类算法
- 博弈论相关，*密码学，阶，原根
-
计算几何
- 向量的点积/叉积，计算几何基础
- *二维计算几何相关，*三维计算几何相关
- *半平面交，*旋转卡壳，*三角剖分
-
搜索
- A*，记忆化搜索，迭代深搜，双向广搜
- 模拟退火，爬山算法，*随机增量法
-
动态规划
- 基础DP，树形DP，数位DP，状压DP，期望DP，基环树DP，*插头DP
- 斜率优化，矩乘优化，单调队列优化，倍增优化，*四边形不等式优化
- trie图DP，*仙人掌DP
-
其他算法
- 构造，乱搞，随机化，三分法，打表，启发式合并
- Huffman树，2-sat，*朱刘算法
说真的，计算几何要么全场不会，要么全场AK。所以尽量花时间在别的地方吧。