之前做过acm,总结出来了一些算法模板。这些是我在搞懂先自己写然后想大牛靠拢不断优化的结果,可能有些是大牛们的源代码,在此一并发出,希望对大家有所帮助,代码中可能有错,在此表示歉意。
- 动态规划模板
- 处理求矩阵的最大子矩
- //************************************************************
- //求a[n][m]的最大子矩阵
- ///计算从某固定行开始起连续列b[i,j]动态规划求最大值
- int dp( const int *b,int m)
- {
- int sum ,max,i;
- sum=max=b[0];
- for(i=1;i<m;i++)
- {
- if(sum>0)sum+=b[i];
- else sum=b[i];
- if(sum>max)max=sum;
- }
- return max;
- }
- //b[k]可以取到任意连续行的排列组合
- max=-999999999;
- for(i=0;i<n;i++)//控制具体哪一行开始
- {
- memset(b,0,sizeof(b));
- for(j=i;j<n;j++)//表示从第i行到最后n行中间每列累加得b[k]
- {
- for(k=0;k<m;k++)
- b[k]+=a[j][k];
- if(dp(b,m)>max) max=dp(b,m);
- }
- }
- //************************************************************
- 动态规划求最大面积
- //************************************************************
- {
- 首先开辟数组a[N],l[N],r[N]
- 找出其左右区间比其大的区间长度
- l[1]=1;
- r[n]=n;
- for (i=2; i<=n; ++i)
- {
- t=i;
- while (t>1 && a[i]<=a[t-1]) t=l[t-1];
- l[i]=t;
- }
- for (i=n-1; i>=1; --i)
- {
- t=i;
- while (t<n && a[i]<=a[t+1]) t=r[t+1];
- r[i]=t;
- }
- /分别以每个小矩形的高度为高求大矩形面积,并找出其最大者
- max=0;
- for (i=1; i<=n; ++i)
- {
- if ((r[i]-l[i]+1)*a[i]>max) max=(r[i]-l[i]+1)*a[i];
- }
- }
- //************************************************************
- 最长公共子序列
- //*********************************************************
- //算法1:时间复杂度为O(N*M),空间复杂度为O(N*N)
- const int MAXN=1000;
- char str1[MAXN],str2[MAXN];
- int dp[MAXN][MAXN];
- int LCS1(char *str1,char *str2)
- {
- int len1=strlen(str1);
- int len2=strlen(str2);
- int i,j;
- memset(dp,0,sizeof(dp));
- for(i=1;i<=len1;i++)
- {
- for(j=1;j<=len2;j++)
- {
- if(str1[i-1]==str2[j-1])
- dp[i][j]=dp[i-1][j-1]+1;
- else if(dp[i-1][j]>dp[i][j-1])
- dp[i][j]=dp[i-1][j];
- else dp[i][j]=dp[i][j-1];
- }
- }
- return dp[len1][len2];
- }
- //===============================================//算法2:时间复杂度为O(N*M),空间复杂度为O(N)
- const int MAXN=1000;
- char str1[MAXN],str2[MAXN];
- int dp[2][MAXN];//采用滚动数组优化
- int LCS2(char *str1,char *str2)
- {
- int len1=strlen(str1);
- int len2=strlen(str2);
- int i,j,k;
- memset(dp,0,sizeof(dp));
- for(i=1;i<=len1;i++)
- {
- k=i&1;
- for(j=1;j<=len2;j++)
- {
- if(str1[i-1]==str2[j-1])
- dp[k][j]=dp[k][j-1]+1;
- else if(dp[k^1][j]>dp[k][j-1])
- dp[k][j]=dp[k^1][j];
- else dp[k][j]=dp[k][j-1];
- }
- }
- return dp[k][len2];
- }
- //*********************************************************
- 最长公共递增子序列
- //************************************************************
- //其中a[n],b[n]分别存放俩序列
- memset(dp,0,sizeof(dp));
- max=0;
- for(i=0;i<n;i++)
- {
- k=0;
- for(j=0;j<m;j++)
- {
- //保证递增又保证找到最大
- if(a[i]>b[j]&&dp[k]<dp[j])
- k=j;
- if(a[i]==b[j])
- dp[j]=dp[k]+1;
- if(max<dp[j])
- max=dp[j];
- }
- }
- //************************************************************
- 数塔问题
- //************************************************************
- //n,m分别表示行数列数
- void shuta(int n,int m)
- {
- int i,j;
- memset(data,0,sizeof(data));
- memset(dp,0,sizeof(dp));
- for(i=1;i<=n;i++)
- {
- for(j=1;j<=i;j++)
- {
- cin>>data[i][j];
- }
- }
- for(j=1;j<=m;j++)
- dp[n][j]=data[n][j];
- for(i=n-1;i>=1;i--)
- {
- for(j=i;j>=1;j--)
- {
- dp[i][j]=max(dp[i+1][j]+data[i][j],dp[i+1][j+1]+data[i][j]);
- }
- }
- }
- //************************************************************
- 最长递增子序列
- //求严格递增子序列的最长长度
- //************************************************************
- //算法1的时间复杂度为O(N*log(N))
- const int MAXN=1000;
- int data[MAXN];//存放原始数据
- int MaxV[MAXN];//MaxV[i]存放长度为i的严格递增子序列的最大值的最小值
- //二分查找返回MaxV中大于等于x的组靠左的下标
- int BinaryResearch(int x,int len)
- {
- int mid,low=1,high=len;
- while(low<=high)
- {
- mid=(low+high)>>1;
- if(MaxV[mid]<x)
- low=mid+1;
- else high=mid-1;
- }
- return low;
- }
- //返回原序列中严格递增子序列的最长长度
- int LIS2(int n)
- {
- int i,len=1;
- MaxV[1]=data[0];
- for(i=1;i<n;i++)
- {
- if(data[i]>MaxV[len])//比长度为len的子序列最大值大,直接加进末尾
- MaxV[++len]=data[i];
- else
- {
- int pos=BinaryResearch(data[i],len);
- MaxV[pos]=data[i];
- }
- }
- return len;
- }
- //===============================================
- //算法2的时间复杂度为O(N*N)
- int dp[MAXN];
- //返回原序列中严格递增子序列的最长长度
- int LIS1(int n)
- {
- int i,j,lmax;
- lmax=0;
- for(i=0;i<n;i++)
- {
- dp[i]=1;
- for(j=0;j<i;j++)
- {
- if(data[i]>data[j]&&dp[j]+1>dp[i])
- dp[i]=dp[j]+1;
- }
- if(dp[i]>lmax)lmax=dp[i];
- }
- return lmax;
- }
- //************************************************************
- 最大字段和
- //************************************************************
- void MSS(int n)
- {
- int i;
- int max=NINF;
- memset(dp,0,sizeof(dp));
- for(i=1;i<=n;i++)
- {
- if(dp[i-1]<=0)
- dp[i]=data[i];
- else dp[i]=dp[i-1]+data[i];
- if(max<dp[i])
- max=dp[i];
- }
- cout<<max<<endl;
- }
- //************************************************************
- 多重背包
- //************************************************************
- int dp[100000+10];//视具体情况而定
- struct node
- {
- int num,weight,value;//分别代表每种物品的数量、重量、价值
- }Good[15];//定义每个物品的结构体
- int Max_weight;//背包的载重量
- int max(int a,int b)
- {
- return a<b?b:a;
- }
- void ZeroOnePack(int weight,int value,int lim)
- //对应01背包的求法
- {
- for(int i=lim;i>=weight;i--)
- dp[i]=max(dp[i],dp[i-weight]+value);
- }
- void CompletePack(int weight,int value,int lim)
- //对应完全背包的求法
- {
- for(int i=weight;i<=lim;i++)
- dp[i]=max(dp[i],dp[i-weight]+value);
- }
- void MultiplePack(int weight,int value,int amount,int lim)
- //选定物品后的多重背包的求法
- {
- if(weight*amount>=lim)CompletePack(weight,value,lim);
- else
- {
- for(int k=1;k<amount;)
- {
- ZeroOnePack(k*weight,k*value,lim);
- amount-=k;
- k<<=1;
- }
- ZeroOnePack(amount*weight,amount*value,lim);
- }
- }
- void Solve(int n)
- //解决物品种类数为n的多重背包问题求法
- {
- memset(dp,0,sizeof(dp));
- for(int i=1;i<=n;i++)
- MultiplePack(Good[i].weight,Good[i].value,Good[i].num,Max_weight);
- }
- //************************************************************
- 数据结构
- 单调队列
- const int MAXN=100000+10;
- int da[MAXN],Inc[MAXN],Dec[MAXN];
- int n,m,k,front1,rear1,front2,rear2;
- //维护双端单调队列,求da[]中满足m<=Max-Min<=k最长连续子序列
- int Queue()
- {
- front1=0,rear1=-1,front2=0,rear2=-1;
- int i,ans=0,start=0;
- for(i=0;i<n;i++)
- {
- while(front1<=rear1&&da[Dec[rear1]]<=da[i])//保证Dec队列在start-i区间内的递减
- rear1--;
- Dec[++rear1]=i;
- while(front2<=rear2&&da[Inc[rear2]]>=da[i])//保证inc队列在start-i区间内的递增
- rear2--;
- Inc[++rear2]=i;
- while(da[Dec[front1]]-da[Inc[front2]]>k)
- {
- //保证区间左端点向后滑动一个长度
- if(Dec[front1]-Inc[front2]<0)
- {
- start=Dec[front1]+1;
- front1++;
- }
- else
- {
- start=Inc[front2]+1;
- front2++;
- }
- }
- //满足m<=Max-Min<=k
- if(da[Dec[front1]]-da[Inc[front2]]>=m)
- {
- if(i-start+1>ans)
- ans=i-start+1;
- }
- }
- return ans;
- }
- 并查集
- //*****************************************************************
- 1.求父亲节点并压缩路径
- int par[MAX];
- int Get_par(int a)
- //查找a的父亲节点并压缩路径
- {
- if(par[a]==a)
- return par[a];
- //注意语句的顺序
- int pa=par[a];
- par[a]=Get_par(par[a]);
- //
- return par[a];
- }
- 2.合并
- void Merge(int a,int b)
- //合并a,b
- {
- int pa,pb;
- pa=Get_par(a);
- pb=Get_par(b);
- par[pa]=pb;
- }
- //*****************************************************************
- 线段树
- 不带延迟更新的操作
- //************************************************************
- int da[MAXN];
- struct node
- {
- int left,right,sum;//sum此处灵活处理
- }tree[MAXN*4];
- //1.建立以left,right为左右边界,将数组da中元素存储在首地址从1开始的线段树tree的叶节点上
- void Build( int id,int left,int right)
- {
- tree[id].left=left;
- tree[id].right=right;
- if(left==right)
- {
- //tree[id].sum=da[left];//此处可以直接初始化为对应da[left]
- return ;
- }
- else
- {
- int mid =(left+right)>>1;
- Build(id<<1,left,mid);
- Build((id<<1)|1,mid+1,right);
- //tree[id].sum=tree[(id<<1)].sum+tree[(id<<1)|1].sum;
- }
- }
- //2.在线段树的叶节点pos处加val
- void Updata(int id,int pos,int val)
- {
- tree[id].sum+=val;
- if(tree[id].left==tree[id].right&&tree[id].left==pos)
- {
- return ;
- }
- int mid=(tree[id].left+tree[id].right)>>1;
- if(pos<=mid)
- Updata(id<<1,pos,val);
- else
- Updata((id<<1)|1,pos,val);
- }
- //3.查询区间[left,right]上的和
- int Query(int id,int left,int right)
- {
- if(tree[id].left==left&&tree[id].right==right)
- {
- return tree[id].sum;
- }
- int mid=(tree[id].left+tree[id].right)>>1;
- if(right<=mid)
- return Query(id<<1,left,right);
- if(left>=mid+1)
- return Query((id<<1)|1,left,right);
- return Query(id<<1,left,mid)+Query((id<<1)|1,mid+1,right);
- }
- //************************************************************
- 线段树的延迟更新
- //*****************************************************
- const int MAXN=100000+100;
- struct node
- {
- int left,right,add;
- int Max;
- }tree[MAXN*4];
- void build(int id, int left, int right)
- {
- tree[id].add=0;
- tree[id].left=left;
- tree[id].right=right;
- tree[id].Max=0;
- if(left==right)
- {
- return ;
- }
- else
- {
- int mid=(left+right)>>1;
- build(id<<1,left,mid);
- build((id<<1)|1,mid+1,right);
- }
- }
- void updata(int id,int left,int right,int adi)
- {
- if(tree[id].left==left&&tree[id].right==right)
- {
- tree[id].add+=adi;
- return ;
- }
- int mid=(tree[id].left+tree[id].right)>>1;
- if(right<=mid)
- updata(id<<1,left,right,adi);
- else if(left>mid)
- updata((id<<1)|1,left,right,adi);
- else
- {
- updata(id<<1,left,mid,adi);
- updata((id<<1)|1,mid+1,right,adi);
- }
- tree[id].Max=max(tree[id<<1].Max+tree[id<<1].add,tree[(id<<1)|1].Max+tree[(id<<1)|1].add);
- }
- int query(int id,int left,int right)
- {
- if(tree[id].left==left&&tree[id].right==right)
- {
- return tree[id].Max+tree[id].add;
- }
- int mid=(tree[id].left+tree[id].right)>>1;
- if(tree[id].add!=0)
- {
- updata(id<<1,tree[id].left,mid,tree[id].add);
- updata((id<<1)|1,mid+1,tree[id].right,tree[id].add);
- tree[id].Max=max(tree[id<<1].Max+tree[id<<1].add,tree[(id<<1)|1].Max+tree[(id<<1)|1].add);
- tree[id].add=0;
- }
- if(right<=mid)
- return query(id<<1,left,right);
- else if(left>mid )
- return query((id<<1)|1,left,right);
- else
- {
- return max(query(id<<1,left,mid),query((id<<1)|1,mid+1,right));
- }
- }
- //*****************************************************************
- RMQ问题的ST算法
- //*****************************************************************
- const int MAXN=50000+100;
- const int Mpow=16;//保证2^(Mpow)>MAXN即可
- int data[MAXN];
- int Maxdp[MAXN][Mpow];
- int Mindp[MAXN][Mpow];
- inline int Min(int a,int b)
- {
- return a<b?a:b;
- }
- inline int Max(int a,int b)
- {
- return a>b?a:b;
- }
- inline void init(int n)
- {
- for(int i=1;i<=n;i++)
- {
- Mindp[i][0]=Maxdp[i][0]=data[i];
- }
- }
- //预处理过程,时间复杂度为O(N*log(N))
- //ST算法求区间最值
- //dp[i][j]表示区间[i,i+2^j-1]最值
- //求dp[i][j]时将其分成dp[i][j-1],dp[i+2^(j-1)][j-1]
- //[i,i+2^j-1]=[i,i+2^(j-1)-1]+[i+2^(j-1),i+2^(j-1)+2^(j-1)-1]
- inline void Rmp_ST(int n)
- {
- int l,s;
- for(l=1;l<=16;l++)
- {
- for(s=1;s<=n;s++)
- {
- if(s+(1<<l)-1<=n)
- {
- Maxdp[s][l]=Max(Maxdp[s][l-1],Maxdp[s+(1<<(l-1))][l-1]);
- Mindp[s][l]=Min(Mindp[s][l-1],Mindp[s+(1<<(l-1))][l-1]);
- }
- }
- }
- }
- //查询[s,e]区间最值,下标从1-n
- //求一个最大的k,是k满足2^k<=e-s+1
- //原理:区间[s,e]=区间[s,s+2^k-1]+区间[e-2^k+1,e]
- //s<=e-2^k+1,s+2^k-1<=e保证刚好完全覆盖
- inline void query()
- {
- int s,e,Min_ans,Max_ans;
- scanf("%d%d",&s,&e);
- int k=(int)(log(1.0*e-s+1)/log(2.0));
- Min_ans=Min(Mindp[s][k],Mindp[e-(1<<(k))+1][k]);
- Max_ans=Max(Maxdp[s][k],Maxdp[e-(1<<(k))+1][k]);
- printf("%d\n",Max_ans-Min_ans);
- }
- //*****************************************************************
- 一维树状数组
- //************************************************************
- const int MAXN=8000+100;
- int C[MAXN];
- int Lowbit[MAXN];
- //C[i] = a[i-lowbit(i)+1] + …+ a[i],下表从1开始
- //Lowbit[i]=i&(i^(i-1));或Lowbit[i]=i&(-i);
- //1.查询
- int QuerySum(int p)
- //查询原数组中下标1-p的元素的和
- {
- int nSum=0;
- while(p>0)
- {
- nSum+=C[p];
- p-=Lowbit[p];
- }
- return nSum;
- }
- //2.修改+初始化
- void Modify(int p,int val)
- //原数组中下表为p的元素+val,导致C[]数组中部分元素值的改变
- {
- while(p<=MAXN-10)
- {
- C[p]+=val;
- p+=Lowbit[p];
- }
- }
- //************************************************************
- 二维树状数组
- //*****************************************************************
- 1.修改
- void Add( int y, int x,int a)
- //原数组中下表为[y][x]的元素+a,导致C[][]数组中部分元素值的改变
- {
- while( y <= s )
- {
- int tmpx = x;
- while( tmpx <= s )
- {
- C[y][tmpx] += a;
- tmpx += Lowbit[tmpx];
- }
- y += Lowbit[y];
- }
- }
- 2.查询
- int QuerySum( int y, int x)
- //查询第1行到第y行,第1列到第x列的和
- {
- int nSum = 0;
- while( y > 0 )
- {
- int tmpx = x;
- while( tmpx > 0)
- {
- nSum += C[y][tmpx];
- tmpx -= Lowbit[tmpx];
- }
- y -= Lowbit[y];
- }
- return nSum;
- }
- //*****************************************************************
- 划分树
- //*****************************************************************
- const int MAXN=100010;
- int tree[30][MAXN];//表示每层每个位置的值
- int sorted[MAXN];//已经排序的数
- int toleft[30][MAXN];//toleft[p][i]表示第p层从1到i有多少个数分入左边
- //创建划分树
- //时间复杂度为O(N*log(N))
- void build(int l,int r,int dep)
- {
- int i;
- if(l==r)return;
- int mid=(l+r)>>1;
- int same=mid-l+1;//表示等于中间值而且被分入左边的个数
- for(i=l;i<=r;i++)
- if(tree[dep][i]<sorted[mid])
- same--;
- int lpos=l;
- int rpos=mid+1;
- for(i=l;i<=r;i++)
- {
- if(tree[dep][i]<sorted[mid])//比中间的数小,分入左边
- tree[dep+1][lpos++]=tree[dep][i];
- else if(tree[dep][i]==sorted[mid]&&same>0)
- {
- tree[dep+1][lpos++]=tree[dep][i];
- same--;
- }
- else //比中间值大分入右边
- tree[dep+1][rpos++]=tree[dep][i];
- toleft[dep][i]=toleft[dep][l-1]+lpos-l;//从1到i放左边的个数
- }
- build(l,mid,dep+1);
- build(mid+1,r,dep+1);
- }
- //查询区间第k小的数,[L,R]是大区间,[l,r]是要查询的小区间
- //时间复杂度为O(log(N))
- int query(int L,int R,int l,int r,int dep,int k)
- {
- if(l==r)return tree[dep][l];
- int mid=(L+R)>>1;
- int cnt=toleft[dep][r]-toleft[dep][l-1];//[l,r]中位于左边的个数
- if(cnt>=k)
- {
- //L+要查询的区间前被放在左边的个数
- int newl=L+toleft[dep][l-1]-toleft[dep][L-1];
- //左端点加上查询区间会被放在左边的个数
- int newr=newl+cnt-1;
- return query(L,mid,newl,newr,dep+1,k);
- }
- else
- {
- int newr=r+toleft[dep][R]-toleft[dep][r];
- int newl=newr-(r-l-cnt);
- return query(mid+1,R,newl,newr,dep+1,k-cnt);
- }
- }
- Init()
- {
- memset(toleft,0,sizeof(toleft));
- for(i=1;i<=n;i++)
- {
- scanf("%d",&tree[0][i]);
- sorted[i]=tree[0][i];
- }
- sort(sorted+1,sorted+n+1);
- build(1,n,0);
- }
- //*****************************************************************
- 字符串匹配
- Manacher算法求最长回文子串
- //*****************************************************************
- const int MAXN=1000000+100;
- char str1[MAXN*2],str2[MAXN*2];//待处理字符串
- int num[MAXN*2];
- //将str1变成str2,如abab变成$#a#b#a#b#
- void init()
- {
- int i,id;
- str2[0]='$';
- str2[1]='#';
- for(i=0,id=2;str1[i];i++,id+=2)
- {
- str2[id]=str1[i];
- str2[id+1]='#';
- }
- str2[id]=0;
- }
- //Manacher算法求最长回文子串,时间复杂度为O(N)
- int Manacher()
- {
- int i,ans=0,MxR=0,pos=1;
- for(i=1;str2[i];i++)
- {
- if(MxR>i)num[i]=num[pos*2-i]<(MxR-i)?num[pos*2-i]:(MxR-i);
- else num[i]=1;
- while(str2[i+num[i]]==str2[i-num[i]])
- num[i]++;
- if(num[i]+i>MxR)
- {
- MxR=num[i]+i;
- pos=i;
- }
- if(ans<num[i])
- ans=num[i];
- }
- return ans-1;
- }
- //*****************************************************************
- BF
- //*****************************************************************
- //BF算法查找str2是否是str1的子串,返回str2在str1中首元素的下标
- int BF()
- {
- int i,j,len1,len2;
- len1=strlen(str1);
- len2=strlen(str2);
- i=0;j=0;
- while(i<len1&&j<len2)
- {
- if(str1[i]==str2[j])
- {
- i++;
- j++;
- }
- else
- {
- i=i-j+1;
- j=0;
- }
- }
- if(j==len2)
- return i-j;
- else
- return -1;
- }
- //*****************************************************************
- KMP
- len % (len - next[len]) == 0,那么循环节的循环次数为len / (len - next[len]),否则为1
- //*****************************************************************
- char W[MAXN],T[MAXN];//W为模式串,T为主串
- int next[MAXN];
- //整个KMP算法时间复杂度为O(N+M)
- //KMP算法中计算next[]数组
- void getNext(char *p)
- {
- int j,k,len=strlen(p);
- j=0;
- k=-1;
- next[0]=-1;
- while(j<len)
- {
- if(k==-1||p[j]==p[k])
- {
- next[++j]=++k;
- }
- else k=next[k];
- }
- }
- //KMP算法统计模式串W在主串T中出现的次数
- int KMP_count(char *W,char *T)
- {
- int i,wlen=strlen(W),tlen=strlen(T),j=0,ans=0;
- getNext(W);
- for(i=0;i<tlen;i++)
- {
- while(j>0&&T[i]!=W[j])
- j=next[j];
- if(W[j]==T[i])j++;
- if(j==wlen)
- {
- ans++;
- j=next[j];
- }
- }
- return ans;
- }
- //返回模式串T在主串S中首次出现的位置
- //返回的位置是从0开始的,若没有找到返回-1。
- int KMP_Index(char *W,char *T)
- {
- int i=0, j=0,wlen=strlen(W),tlen=strlen(T);
- getNext(W);
- while(i<tlen&&j<wlen)
- {
- if(j==-1||T[i]==W[j])
- {
- i++; j++;
- }
- else
- j=next[j];
- }
- if(j==wlen)
- return i-wlen;
- else
- return -1;
- }
- //*****************************************************************
- 字符串的最小表示法
- //*****************************************************************
- //返回母串的最小子串的起始位置,返回值从1开始到strlen(str)
- int minpresent(char *str)
- {
- int i,j,k,len=strlen(str);
- i=0,j=1,k=0;
- while(i<len&&j<len&&k<len)
- {
- if(str[(i+k)%len]==str[(j+k)%len])
- k++;
- else
- {
- if(str[(i+k)%len]>str[(j+k)%len])
- i=i+k+1;
- else
- j=j+k+1;
- if(i==j)j++;
- k=0;
- }
- }
- return ++i<++j?i:j;
- }
- //*****************************************************************
- 字典树
- //************************************************************
- //定义字典树结构体
- struct Trie
- {
- Trie* next[26];
- int flag;
- };
- Trie *root;
- //初始化root
- void init()
- {
- root=new Trie;
- memset(root,0,sizeof(Trie));
- }
- //2.插入
- //将str插入以root为根节点的字典树中
- void insert(char *str)
- {
- int len = strlen(str);
- Trie *s = root;
- for (int i = 0; i < len; i++)
- {
- if (s->next[str[i] - 'a'])
- s = s->next[str[i] - 'a'];
- else
- {
- Trie* t = new Trie;
- memset(t, 0, sizeof (Trie));
- s->next[str[i] - 'a'] = t;
- s = t;
- }
- }
- s->flag = 1;
- }
- //3.查找
- //查找字典树中是否有元素str
- int find(char *str)
- {
- int len = strlen(str);
- Trie *s = root;
- for (int i = 0; i < len; i++)
- {
- if (s->next[str[i] - 'a'])
- s = s->next[str[i] - 'a'];
- else
- return 0;
- }
- return s->flag;/flag可能不标志为单词结尾
- }
- //5.释放内存空间
- //释放以root为根节点的字典树内存空间
- void del(Trie *root)
- {
- Trie *s = root;
- for (int i = 0; i < 26; i++)
- {
- if (s->next[i])
- del(s->next[i]);
- }
- delete s;
- s = NULL;
- }
- //*****************************************************************
- AC自动机模板
- //************************************************************
- const int kind = 26;//视具体情况改动
- struct node
- {
- node *fail; //失败指针
- node *next[kind]; //Tire每个节点的26个子节点(最多26个字母)
- int count; //是否为该单词的最后一个节点
- node()
- { //构造函数初始化
- fail=NULL;
- count=0;
- memset(next,NULL,sizeof(next));
- }
- }*q[1000*255]; //队列方便用于bfs构造失败指针,大小应依据Tries图//节点个数而定
- int head,tail; //队列的头尾指针
- node *Root;
- //1.建立Tries
- void insert(char *str,node *root)
- //建立一颗以root为根节点的不带前缀指针的字典树
- {
- node *p=root;
- int i=0,index;
- while(str[i])
- {
- index=str[i]-'A';//视具体情况改动
- if(p->next[index]==NULL)
- p->next[index]=new node();
- p=p->next[index];
- i++;
- }
- p->count=1;
- }
- //2.建立前缀指针,形成Tries图
- void build_ac_automation(node *root)
- //在建好的字典树上添加前缀指针,形成Tries图,即ac自动机
- {
- int i;
- root->fail=NULL;
- q[head++]=root;
- while(head!=tail)
- {
- node *temp=q[tail++];
- node *p=NULL;
- for(i=0;i<kind;i++)
- {
- if(temp->next[i]!=NULL)
- {
- if(temp==root)
- temp->next[i]->fail=root;
- else
- {
- p=temp->fail;
- while(p!=NULL)
- {
- if(p->next[i]!=NULL)
- {
- temp->next[i]->fail=p->next[i];
- break;
- }
- p=p->fail;
- }
- if(p==NULL)
- temp->next[i]->fail=root;
- }
- q[head++]=temp->next[i];
- }
- }
- }
- }
- //3.查询母串
- int query(node *root,char *s)
- //有多少种模式串出现在母串str[]中
- {
- int i=0,cnt=0,index,len=strlen(s);
- node *p=root;
- while(s[i])
- {
- index=s[i]-'A';//视具体情况改动
- while(p->next[index]==NULL && p!=root)
- p=p->fail;
- p=p->next[index];
- p=(p==NULL)?root:p;
- node *temp=p;
- while(temp!=root&&temp->count)
- {
- cnt+=temp->count;
- temp->count=0;
- temp=temp->fail;
- }
- i++;
- }
- return cnt;
- }
- //4.初始化
- void init()
- {
- head=tail=0;
- Root=new node;
- }
- //************************************************************
- 后缀数组
- //*****************************************************************
- const int MAXN=100000+100;
- char str[MAXN];//待处理字符串
- int sa[MAXN];//求得的后缀数组
- int wa[MAXN],wb[MAXN],wv[MAXN],wh[MAXN];
- int cmp(int *r,int a,int b,int l)
- {
- return r[a]==r[b]&&r[a+l]==r[b+l];
- }
- //求后缀数组sa[],下标1到n-1(此处n=strlen(str)+1)有效后缀
- //将str的n个后缀从小到大进行排序之后把排好序的后缀的开头位置顺次放入sa中。
- //保证Suffix(sa[i])<Suffix(sa[i+1])
- //1<=i<n,sa[0]存放人为添加在末尾的那个最小的后缀
- //倍增算法的时间复杂度为O(nlogn)
- //倍增算法的空间复杂度都是O(n)
- void da(char *r,int *sa,int n,int m)
- {
- int i,j,p,*x=wa,*y=wb,*t;
- for(i=0;i<m;i++) wh[i]=0;
- for(i=0;i<n;i++) wh[x[i]=r[i]]++;
- for(i=1;i<m;i++) wh[i]+=wh[i-1];
- for(i=n-1;i>=0;i--) sa[--wh[x[i]]]=i;
- for(j=1,p=1;p<n;j*=2,m=p)
- {
- for(p=0,i=n-j;i<n;i++) y[p++]=i;
- for(i=0;i<n;i++) if(sa[i]>=j) y[p++]=sa[i]-j;
- for(i=0;i<n;i++) wv[i]=x[y[i]];
- for(i=0;i<m;i++) wh[i]=0;
- for(i=0;i<n;i++) wh[wv[i]]++;
- for(i=1;i<m;i++) wh[i]+=wh[i-1];
- for(i=n-1;i>=0;i--) sa[--wh[wv[i]]]=y[i];
- for(t=x,x=y,y=t,p=1,x[sa[0]]=0,i=1;i<n;i++)
- x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;
- }
- return;
- }
- int rank[MAXN],height[MAXN];
- //定义height[i]=suffix(sa[i-1])和suffix(sa[i])的最长公
- //共前缀,也就是排名相邻的两个后缀的最长公共前缀
- //任意两个起始位置为i,j(假设rank[i]<rank[j])的后缀的最长公共前缀
- //为height[rank[i]+1]、height[rank[i]+2]…height[rank[j]]的最小值
- void calheight(char *r,int *sa,int n)
- {
- int i,j,k=0;
- for(i=1;i<=n;i++) rank[sa[i]]=i;
- for(i=0;i<n;height[rank[i++]]=k)
- for(k?k--:0,j=sa[rank[i]-1];r[i+k]==r[j+k];k++);
- return;
- }
- //求不可重叠最长重复子串
- //先二分答案,把题目变成判定性问题:判断是否
- //存在两个长度为k 的子串是相同的,且不重叠
- //时间复杂度为O(N*log(N))
- int Bin_Solve(int n)
- {
- int i,Minlen,Maxlen,midlen,lowid,highid;
- bool flag;
- Minlen=0,Maxlen=n/2;
- while(Minlen<=Maxlen)//二分重复字串的长度
- {
- midlen=(Minlen+Maxlen)/2;
- lowid=n+1,highid=0;
- flag=false;
- for(i=1;i<=n&&!flag;i++)//此处i表示排名
- {
- if (height[i]<midlen)lowid=highid=sa[i];//中间有一个的长度不大于midlen,就断开了
- //即说明前面的和后面的最长公共前缀不可能大于等于miflen
- else if(height[i]>=midlen)//长度大于等于midlen
- {
- lowid=min(lowid,sa[i]);
- highid=max(highid,sa[i]);
- if(highid-lowid>=midlen)//且不重叠
- flag=true;
- }
- }
- if(flag)Minlen=midlen+1;
- else Maxlen=midlen-1;
- }
- return Maxlen<4?0:Maxlen+1;
- }
- //*****************************************************************
- 4.图论
- 邻接表建图
- //*****************************************************
- const int MAXN=1000+100;
- const int INF = 0x3f3f3f3f;
- int head[MAXN];
- int dis[MAXN];
- bool visited[MAXN];
- int qq[MAXN];//模拟队列
- struct node
- {
- int to;
- int next;
- }Edg[20000+100];
- int n,m,tot;
- void init()
- {
- tot=0;
- memset(head,-1,sizeof(head));
- }
- void add(int a,int b)
- {
- Edg[tot].to=b;
- Edg[tot].next=head[a];
- head[a]=tot++;
- }
- void BFS(int s)
- {
- //queue<int>qq;
- //qq.push(s);
- int front,rear;
- front=rear=0;
- qq[front++]=s;
- int now,i,to;
- for(i=1;i<=n;i++)
- {
- if(i!=s)dis[i]=INF;
- else dis[i]=0;
- }
- visited[s]=true;
- while(rear<front)
- {
- //now=qq.front();
- //qq.pop();
- now=qq[rear++];
- for(i=head[now];i!=-1;i=Edg[i].next)
- {
- to=Edg[i].to;
- if(to==now||visited[to])continue;
- dis[to]=dis[now]+1;
- //qq.push(to);
- qq[front++]=to;
- visited[to]=true;
- }
- }
- }
- //*****************************************************
- 二分图:
- 模板一:匈牙利算法
- //************************************************************
- //二分图匹配(匈牙利算法的DFS实现)
- //初始化:g[][]两边顶点的划分情况
- //建立g[i][j]表示i->j的有向边就可以了,是左边向右边的匹配
- //g没有边相连则初始化为0
- //uN是匹配左边的顶点数,vN是匹配右边的顶点数
- //调用:res=hungary();输出最大匹配数
- //优点:适用于稠密图,DFS找增广路,实现简洁易于理解
- //时间复杂度:O(VE)
- //************************************************************
- //顶点编号从0开始的
- const int MAXN=510;
- int uN,vN;//u,v数目
- int g[MAXN][MAXN];
- int linker[MAXN];
- bool visited[MAXN];
- bool dfs(int u)//从左边开始找增广路径
- {
- int v;
- for(v=0;v<vN;v++)//这个顶点编号从0开始,若要从1开始需要修改
- if(g[u][v]&&!visited[v])
- {
- visited[v]=true;
- if(linker[v]==-1||dfs(linker[v]))
- {//找增广路,反向
- linker[v]=u;
- return true;
- }
- }
- return false;//这个不要忘了,经常忘记这句
- }
- int hungary()
- {
- int res=0;
- int u;
- memset(linker,-1,sizeof(linker));
- for(u=0;u<uN;u++)
- {
- memset(visited,0,sizeof(visited));
- if(dfs(u)) res++;
- }
- return res;
- }
- //****************************************************
- 最小生成树的Kruskal算法
- //************************************************************
- //带权值的无向图的最小生成树的Kruskal算法
- int id[maxm];//id[]存放边的下标,从[0-m-1]
- int eu[maxm],ev[maxm],ew[maxm];//依次存放无向边的两顶点和权值
- int n,m;//n为顶点数,m为边数
- int par[maxn];//并查集中存放顶点的数组
- int cmp( const int &i , const int &j)
- {
- return ew[i]<ew[j];
- }
- int Get_Par( int x)
- {
- if( par[x]==x)
- return par[x];
- par[x]=Get_Par(par[x]) ;
- return par[x] ;
- }
- int Kruskal( )
- {
- int ret=0, i , j , p ;
- for(i=1;i<=n;i++)
- par[i]=i; // node [ 1 . . n ]
- for(i=0;i<m;i++)
- id[i]=i ; // ew [ 0 . .m.1]
- std::sort(id,id+m,cmp) ;
- for(j=-1,i=1;i<n;i++)
- {
- while(p=id[++j],Get_Par(eu[p])==Get_Par(ev[p]));
- ret+=ew[p];
- par[Get_Par(ev[p])]=Get_Par(eu[p]) ;
- }
- return ret;
- }
- //************************************************************
- Dijkstra算法
- //************************************************************
- #define INF 0x3f3f3f3f
- #define Max 155
- int n;//表示顶点数目
- int dis[Max];//dis数组表示源点到各点的距离
- int g[Max][Max];//用邻接矩阵g[][]存放图的边
- bool visited[Max];//标记原点到该点的最短距离是否找到
- //开始应初始化memset(g, INF, sizeof(g));
- void Dijkstra(int start)
- {
- int temp,k,i,j;
- memset(visited,false,sizeof(visited));
- for(i=1;i<=n;++i)
- dis[i]=g[start][i];
- dis[start]=0;
- visited[start]=1;
- for(i=1;i<=n;++i)
- {
- temp=INF;
- for(int j=1;j<=n;++j)
- if(!visited[j]&&temp>dis[j])
- temp=dis[k=j];
- if(temp==INF)break;
- visited[k]=1;
- for(j=1;j<=n;++j)
- if(!visited[j]&&dis[j]>dis[k]+g[k][j])
- dis[j]=dis[k]+g[k][j];
- }
- }
- //************************************************************
- flyod算法
- //*****************************************************************
- int const Max=1001;
- int a[Max][Max];//存放边的权值
- int b[Max];//存放顶点的权值
- int nex[Max][Max]; //next[i][j]用来保存i-->j的最短路径中i的最优后即最近的顶点
- int N;
- void floyd()
- //flyod算法求个顶点间的最短路径长度并记录路径
- {
- int i,j,k,fee;
- for(i=1;i<=N;i++)
- for(j=1;j<=N;j++)
- nex[i][j]=j;
- for(k=1;k<=N;k++)
- {
- for(i=1;i<=N;i++)
- {
- if(i==k||a[i][k]==-1)
- continue;
- for(j=1;j<=N;j++)
- {
- if(a[k][j]==-1||j==k)
- continue;
- fee = a[i][k]+a[k][j]+b[k];
- if(a[i][j]==-1||a[i][j]>fee)
- {
- a[i][j]=fee;
- nex[i][j]=nex[i][k];
- }
- //选择字典序小的路径
- else if(a[i][j]==fee)
- {
- if(nex[i][j]>nex[i][k])
- nex[i][j]=nex[i][k];
- }
- }
- }
- }
- }
- void path(int i, int j)
- //递归输出最短路径
- {
- if(j==nex[i][j])
- {
- printf("%d-->%d\n",i,j);
- }
- else
- {
- printf("%d-->",i);
- path(nex[i][j],j);
- }
- }
- //*****************************************************************
- 数论
- 矩阵快速幂
- //*****************************************************
- //origin存放需计算的矩阵,res存放答案矩阵
- //最终答案为res.a[1][0](对应f[n])
- struct matrix
- {
- __int64 a[2][2];
- };
- matrix origin,res;
- //将res初始化为初始条件矩阵,人为输入关系递推矩阵origin
- void init()
- {
- origin.a[0][0]=1,origin.a[1][0]=origin.a[0][1]=1,origin.a[1][1]=0;
- res.a[0][0]=1,res.a[0][1]=res.a[1][0]=res.a[1][1]=0;
- }
- //直接将2个矩阵相乘x*y,返回计算后的矩阵
- matrix multiply(matrix &x,matrix &y,__int64 MOD)
- {
- matrix temp;
- memset(temp.a,0,sizeof(temp.a));
- for(int i=0;i<2;i++)
- {
- for(int j=0;j<2;j++)
- {
- for(int k=0;k<2;k++)
- {
- temp.a[i][j]+=x.a[i][k]*y.a[k][j];
- temp.a[i][j]%=MOD;
- }
- }
- }
- return temp;
- }
- //矩阵快速幂的计算,矩阵的n次幂,每个中间结果对MOD取模
- void calc(matrix &origin,matrix &res,__int64 n,__int64 MOD)
- {
- while(n)
- {
- if(n&1)
- res=multiply(origin,res,MOD);
- n>>=1;
- origin=multiply(origin,origin,MOD);
- }
- }
- //*****************************************************
- 快速幂
- A^B %C=A^( B%phi(C)+phi(C) ) %C B>=phi(C)
- //************************************************************
- //快速幂x^n%mod的计算
- __int64 optimized_pow_n(__int64 x, __int64 n)
- {
- __int64 pw = 1;
- while (n > 0)
- {
- if (n & 1)
- pw *= x;
- pw=pw%mod;
- x *= x;
- x=x%mod;
- n >>= 1;
- }
- return pw;
- }
- //************************************************************
- 三分法求凹凸函数的极值点
- //*****************************************************
- //当需要求某凸性或凹形函数的极值,通过函数本身表达式并不容易求解时,就可以用三分法不断逼近求解
- double mid, midmid;
- while ( low + eps < high )
- {
- mid = (low + high) / 2;
- midmid = (mid + high ) / 2;
- double cmid = cal(mid);
- double cmidmid = cal(midmid);
- if ( cmid > cmidmid )
- high = midmid;
- else
- low = mid;
- }
- //*****************************************************
- 普通母函数
- //*****************************************************
- //普通母函数,求组合数。
- int n,sum;//n表示物品种类数,sum为在[1,sum]范围类求每个价值的组合数(不排列)
- int num[100+10],value[100+10];//num[]存放该种类对应的个数,value[]存放该种类对应的价值
- int a[10000+100];
- int b[10000+100];
- void Generating_function()
- {
- int i,j,k;
- memset(a,0,sizeof(a));
- memset(b,0,sizeof(b));
- a[0]=1;
- for(i=1;i<=n;i++)
- {
- for(j=0;j<=sum;j++)
- {
- for(k=0;k<=num[i]&&k*value[i]+j<=sum;k++)
- {
- b[k*value[i]+j]+=a[j];
- b[k*value[i]+j]%=10000;
- }
- }
- memcpy(a,b,sizeof(b));
- memset(b,0,sizeof(b));
- }
- }
- //*****************************************************
- 最大公约数
- //*****************************************************
- //求a,b的最大公约数
- LL Gcd(LL a,LL b)
- {
- return b==0?a:Gcd(b,a%b);
- }
- //*****************************************************
- 计算几何
- //求不共线三点的外接圆,利用圆心到三点距离相等联立方程求得
- point GetCentre(point a,point b,point c)
- {
- double a1=b.x-a.x,b1=b.y-a.y,c1=(a1*a1+b1*b1)/2;
- double a2=c.x-a.x,b2=c.y-a.y,c2=(a2*a2+b2*b2)/2;
- double d=a1*b2-a2*b1;
- point ret;
- ret.x=a.x+(c1*b2-c2*b1)/d;
- ret.y=a.y+(a1*c2-a2*c1)/d;
- return ret;
- }
- 头文件及宏定义
- #include<iostream>
- #include<sstream>
- #include<fstream>
- #include<vector>
- #include<list>
- #include<deque>
- #include<queue>
- #include<stack>
- #include<map>
- #include<set>
- #include<bitset>
- #include<algorithm>
- #include<cstdio>
- #include<cstdlib>
- #include<cstring>
- #include<cctype>
- #include<cmath>
- #include<ctime>
- #include <numeric>
- using namespace std;
- const double eps(1e-8);
- const int INF = 0x3f3f3f3f;
- //优先级队列的两种定义方式
- struct cmp//对应大顶堆
- {
- bool operator()(int a,int b)
- {
- return a<b;
- }
- };
- priority_queue<int,vector<int>,cmp>Q;
- struct node
- {
- int id;
- bool operator < (const node& b)const
- {
- return id>b.id;
- }
- };
- priority_queue<node>Q;
- //set,multiset用法
- struct cmp
- {
- bool operator ()(const node &a,const node &b)const
- {
- return a.nam<b.nam;//从小到大排序
- }
- };
- multiset<node,cmp>MulSet;//存放未处理