- 并查集
- KMP算法
- 树状数组
- 线段树
- 莫队算法
1、并查集
描述: 一种用来管理元素分组情况的数据结构。并查集可以高效的进行如下操作：
- 查询元素a和元素b是否属于同一个数组。
- 合并元素a和元素b所在的组。
代码:
// 并查集
int par[Max_n]; //父亲
int rank[Max_n]; //树的高度
void init(int n){ //初始化n个元素
for(int i=0;i<n;i++){
par[i]=i;
rank[i]=0;
}
}
int find(int x){ //查询树的根（路径压缩）
if(par[x]==x)return x;
return par[x]=find(par[x]);
}
int find(int x){ //非递归写法
int p,t;
p=x;
while(x!=par[x])x=par[x];
while(p!=x){
t=par[p];
par[p]=x;
p=t;
}
return x;
}
void unite(int x,int y){ //合并x和y所属的集合（按秩归并）
x=find(x);
y=find(y);
if(x==y)return;
if(rank[x]<rank[y])par[x]=y;
else par[y]=x;
if(rank[x]==rank[y])rank[x]++;
}
**复杂度:**加入优化后效率非常高，对n个元素的元素进行一次操作的复杂度是O(α(n))，比O(logn)还要快。
2、KMP算法
描述: KMP算法是一种改进的字符串匹配算法，是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的，时间复杂度O(m+n)。
- pmt数组记录的是字符串前缀集合和后缀集合的最长匹配。为了编程的方便，不直接使用pmt数组，而pmt数组向后偏移一位得到next数组。即next数组 记录的是主串字符与模式串字符失配时，主串应与模式串的第next[j]个字符再进行比较。
代码:
next是C++中的保留字，使用next数组，会CE！
char s[Max_n],t[Max_n];
int next[Max_n];
int slen,tlen;
void getNext(){ //next数组
int i=0,j=-1;
next[0]=-1;
while(i<tlen){
if(j==-1||t[i]==t[j]){
i++;j++;
next[i]=j;
}
else j=next[j];
}
}
void getNext2(){ //优化的next数组
int i=0,j=-1;
next[0]=-1;
while(i<tlen){
if(j==-1||t[i]==t[j]){
i++;j++;
if(t[i]==t[j])next[i]=next[j];
else next[i]=j;
}
else j=next[j];
}
}
int kmp_index(){ //返回模式串T在主串S中首次出现的位置
int i=0,j=0;
getNext();
while(i<slen&&j<tlen){
if(j==-1||s[i]==t[j]){
i++;j++;
}
else j=next[j];
}
if(j==tlen)return i-j;
else return -1;
}
int kmp_count(){ //返回模式串在主串S中出现的次数
int i=0,j=0,k=0;
getNext();
while(i<slen){
if(j==-1||s[i]==t[j]){
i++;j++;
}
else j=next[j];
if(j==tlen){
k++;
j=next[j];
}
}
return k;
}
// KMP求最小循环节、循环周期
定理：假设S的长度为len，则S存在最小循环节，循环节的长度L为len-next[len]，子串为S[0…len-next[len]-1]。
（1）如果len可以被len - next[len]整除，则表明字符串S可以完全由循环节循环组成，循环周期T=len/L。
（2）如果不能，说明还需要再添加几个字母才能补全。需要补的个数是循环个数L-len%L=L-(len-L)%L=L-next[len]%L。
简单理解：
对于字符串abcd abcd abcd，由长度为4的字符串abcd重复3次得到，那么必然有原字符串的前八位等于后八位。
也就是说，对于某个字符串S，由长度为L的字符串s重复R次得到，当R≥2时必有S[0..len-L-1]=S[L..len-1](下标从0开始)
那么对于KMP算法来说，就有next[len]=len-L。此时L肯定已经是最小的。
（因为next的值是前缀和后缀相等的最大长度，即len-L是最大的，那么在len已经确定的情况下，L是最小的）。
next数组和优化后的next2数组：
3、树状数组
描述: 树状数组用来维护数组的前缀和，从而可以快速求得某一个区间的和，并支持对元素的值进行修改。但是树状数组并非只有这一种功能，变形后它还能衍生出两个功能，本文我们就来分别讨论下树状数组这三大功能。
永远要记住，基本的树状数组维护的是数组的前缀和，所有的区间求值都可以转化成用 sum[m]-sum[n-1] 来解，这点无论是在改点还是接下来要说的改段中都非常重要！
1.改点求段（单点修改 区间查询）
这也是树状数组的基本应用。我们可以来看一下这道题 敌兵布阵。
代码:
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int Max_n=1e5+10;
int t,n,k=0;
int c[Max_n];
int lowbit(int k){
return k&-k;
}
void update(int k,int val){
while(k<=n){
c[k]+=val;
k+=lowbit(k);
}
}
int sum(int k){
int ans=0;
while(k>0){
ans+=c[k];
k-=lowbit(k);
}
return ans;
}
int main()
{
scanf("%d",&t);
while(t--){
scanf("%d",&n);
int a,b;
char s[10];
memset(c,0,sizeof(c));
for(int i=1;i<=n;i++){
scanf("%d",&a);
update(i,a);
}
printf("Case %d:\n",++k);
while(~scanf("%s",s)&&s[0]!='E'){
if(s[0]=='Q'){
scanf("%d%d",&a,&b);
printf("%d\n",sum(b)-sum(a-1));
}
else if(s[0]=='A'){
scanf("%d%d",&a,&b);
update(a,b);
}
else {
scanf("%d%d",&a,&b);
update(a,-b);
}
}
}
return 0;
}
2.改段求点（区间修改 单点查询）
改段求点和改点求段恰好相反，比如有一个数组 a = [x, 0, 0, 0, 0, 0, 0, 0, 0, 0]，每次的修改都是一段，比如让 a[1]~a[5] 中每个元素都加上10，让 a[6]~a[9] 中每个元素都减去2，求任意的元素的值。
看例题： Color the ball
跟改点求段不同，这里要转变一个思想。在改点求段中，c[i]表示Ci节点所管辖的子节点的元素和，而在改段求点中，c[i]表示Ci所管辖子节点的批量统一增量。
还是看这个经典的图：
比方说，C8管辖A1A8这8个节点，如果A1A8每个都染色一次，因为前面说了c[i]表示i所管辖子节点的统一增量，那么也就是 c[8]+=1，A5~A7都染色两次，也就是 c[6] +=2, c[7] +=2 。如果要求A1被染色的次数，C8是能管辖到A1的，也就是说c[8]的值和A1被染色的次数有关，仔细想想，也就是把能管辖到A1的父节点的c值累积起来即可。两个过程正好和改点求段相反。
代码:
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int Max_n=1e5+10;
int n;
int c[Max_n];
int lowbit(int k){
return k&-k;
}
void update(int k,int val){
while(k>0){
c[k]+=val;
k-=lowbit(k);
}
}
int query(int k){
int ans=0;
while(k<=n){
ans+=c[k];
k+=lowbit(k);
}
return ans;
}
int main()
{
while(~scanf("%d",&n)&n){
memset(c,0,sizeof(c));
int a,b;
for(int i=0;i<n;i++){
scanf("%d%d",&a,&b);
update(a-1,-1);update(b,1);
}
printf("%d",query(1));
for(int i=2;i<=n;i++)
printf(" %d",query(i));
putchar('\n');
}
return 0;
}
3.改段求段（区间修改 区间查询）
改段求段也有道经典的模板题：A Simple Problem with Integers
我们还是从简单的例子入手，比如有数组a[10]={1,2,3…9}。
假设我们将 a[1]~a[4] 这段增加5，对于我们要求的区间和来说，要么是 [1,2] 这种属于所改段的子区间，要么是 [1,8] 这种属于所改段的父区间（前面说了，所有的区间求值都可以用sum[m]-sum[n-1]来解，所以我们只考虑前缀和），我们分别讨论。
1）如果所求是类似 [1,8] 这种，我们可以很开心地发现，我们将区间增量(4*5)全部加在 a[4] 这个元素上，对结果并没有什么影响！于是变成了一般的改点求段。
2）如果所求是类似 [1,2] 这种，我们可以用类似改段求点中染色的思想进行处理。譬如 [1,4] 成段加5，如果我们要计算 [1,2] 的和。我们将 [1,3] 进行“染色”（节点4加上了4*5的权重），因为 [1,3] 在树状数组的划分中可以分为两个区间，[1,2] 和 [3,3]，所以我们用类似改段求点对这两块区域进行“染色”，染上的次数为5。我们要求的是 [1,2] 的区间和，我们只需找 2 被染色的次数，因为 [1,n] 进行染色。如果m(1<=m<=n)被染色，那么m的左边肯定都被染色了。求出被染色的次数，然后乘上区间宽度，就是整段的和了。
这样我们分别对两种情况进行了处理，更重要的是，这两种情况互不影响！于是我们简单地把两个结果相加就ok了，而这两个过程，分别正是改点求段和改段求点！
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int Max_n=1e5+10;
int N,Q;
ll b[Max_n],c[Max_n];
int lowbit(int k){
return k&-k;
}
void update_backward(int k,int val){
while(k<=N){
b[k]+=val;
k+=lowbit(k);
}
}
void update_forward(int k,int val){
while(k>0){
c[k]+=val;
k-=lowbit(k);
}
}
void update(int k,int val){
update_backward(k,k*val);
update_forward(k-1,val);
}
ll query_forward(int k){
ll ans=0;
while(k>0){
ans+=b[k];
k-=lowbit(k);
}
return ans;
}
ll query_backward(int k){
ll ans=0;
while(k<=N){
ans+=c[k];
k+=lowbit(k);
}
return ans;
}
ll query(int k){
return query_forward(k)+k*query_backward(k);
}
int main()
{
scanf("%d%d",&N,&Q);
int x,y,z;
char s[10];
memset(b,0,sizeof(b));
memset(c,0,sizeof(c));
N+=1; //下标2~n+1
for(int i=2;i<=N;i++){
scanf("%d",&x);
update_backward(i,x);
}
for(int i=0;i<Q;i++){
scanf("%s",s);
if(s[0]=='Q'){
scanf("%d%d",&x,&y);
x++;y++;
printf("%lld\n",query(y)-query(x-1));
}
else {
scanf("%d%d%d",&x,&y,&z);
x++;y++;
update(y,z);
update(x-1,-z);
}
}
return 0;
}
注意： 一般的用数组来解的题，都是不用a[0]的，也就是元素是从a[1]~a[n]。而本题中的改段求段中的元素是从 a[2]~a[n+1]，因为 update()更新区间[1,x]（x为任意值）时，左端点为0向后更新update_backward会造成死循环！
// 支持本小节树状数组原创作者：韩子迟，十分感谢~~
4、线段树
描述: 是一种树状结构来存储一个连续区间的信息的数据结构。线段树是平衡二叉树，所有操作都是logn级别，每个节点对应一个区间。关键的一点：需要维护哪些区间的附件信息，怎样维护这个信息。
代码风格：
- 数组要开节点数Max_n的4倍，详见证明，lson和rson分别代表当前节点的左右儿子。
- 函数传参时，同时传递当前儿子的节点rt和对应的区间[l,r]。
- pushUP(int rt) 把当前结点的信息更新给父结点。
pushDown(int rt) 把当前结点的信息更新给儿子结点。 - 线段树维护的区间范围是[1,x]，根节点从1开始（1,2,3…）!!!
hdu-1166 敌兵布阵
- 简单的单点修改，区间查询
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
const int Max_n=5e4+10;
int tree[Max_n<<2];
void pushUp(int rt){
tree[rt]=tree[rt<<1]+tree[rt<<1|1];
}
void build(int l,int r,int rt){
if(l==r){
scanf("%d",&tree[rt]);
return;
}
int m=(l+r)>>1;
build(lson);build(rson);
pushUp(rt);
}
void update(int k,int value,int l,int r,int rt){ //单点更新
if(l==r){
tree[rt]+=value;
return;
}
int m=(l+r)>>1;
if(k<=m)update(k,value,lson);
else update(k,value,rson);
pushUp(rt);
}
int query(int L,int R,int l,int r,int rt){
if(r<=R&&l>=L)return tree[rt];
int ans=0;
int m=(l+r)>>1;
if(L<=m)ans+=query(L,R,lson);
if(R>=m+1)ans+=query(L,R,rson);
return ans;
}
int main()
{
int T,n;
scanf("%d",&T);
for(int i=1;i<=T;i++){
printf("Case %d:\n",i);
scanf("%d",&n);
build(1,n,1);
char s[110];
int x,y;
while(~scanf("%s",s)&&s[0]!='E'){
scanf("%d%d",&x,&y);
if(s[0]=='A')update(x,y,1,n,1);
else if(s[0]=='S')update(x,-y,1,n,1);
else printf("%d\n",query(x,y,1,n,1));
}
}
return 0;
}
poj 3468 A Simple Problem with Integers
- 区间修改，区间查询（lazy标记）
- lazy标记思想：更新到某个区间的时候，先给这个区间打上lazy标记，不去更新子区间。当下一次更新子区间的时候再把该区间的lazy标记更新到子区间。从而避免浪费更新那些不必要的结点的时间。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
using namespace std;
typedef long long ll;
const int Max_n=1e5+10;
int s[Max_n];
ll sum[Max_n<<2];
int lazy[Max_n<<2];
void pushUp(int rt){
sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}
void pushDown(int rt,int len){
if(lazy[rt]){
lazy[rt<<1]+=lazy[rt];
lazy[rt<<1|1]+=lazy[rt];
sum[rt<<1]+=(len-(len>>1))*lazy[rt];
sum[rt<<1|1]+=(len>>1)*lazy[rt];
lazy[rt]=0;
}
}
void build(int l,int r,int rt){
lazy[rt]=0;
if(l==r){
sum[rt]=s[l];
return;
}
int m=(l+r)>>1;
build(lson);build(rson);
pushUp(rt);
}
void update(int L,int R,int c,int l,int r,int rt){
if(l>=L&&r<=R){
lazy[rt]+=c;
sum[rt]+=(ll)c*(r-l+1);
return;
}
int m=(l+r)>>1;
pushDown(rt,r-l+1);
if(L<=m)update(L,R,c,lson);
if(R>=m+1)update(L,R,c,rson);
pushUp(rt);
}
ll query(int L,int R,int l,int r,int rt){
if(l>=L&&r<=R)return sum[rt];
pushDown(rt,r-l+1);
int m=(l+r)>>1;
ll ans=0;
if(L<=m)ans+=query(L,R,lson);
if(R>=m+1)ans+=query(L,R,rson);
return ans;
}
int main()
{
int n,t;
scanf("%d%d",&n,&t);
for(int i=1;i<=n;i++)scanf("%d",&s[i]);
build(1,n,1);
char ch;
int x,y,z;
while(t--){
cout<<t<<'&'<<endl;
scanf("%c",&ch);
if(ch=='Q'){
scanf("%d%d",&x,&y);
printf("%lld\n",query(x,y,1,n,1));
}
else {
scanf("%d%d%d",&x,&y,&z);
update(x,y,z,1,n,1);
}
}
return 0;
}
5、莫队算法
描述： 一种优雅的暴力，离线处理一类区间不修改查询类问题的算法。通过预先知道所有的询问，合理的组织每个询问的顺序以此来降低复杂度。
复杂度： O(n*√n)
66666666666666666666666666
3742
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
