算法模板总结

已于 2023-11-17 16:26:56 修改
阅读量160 收藏
点赞数
分类专栏： CSP与NOIP的复习与练习 文章标签： 算法 c++
于 2023-10-10 22:44:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mike_code/article/details/133756664
版权

目录

解题技巧

快读快输

攻略引用

#include <bits/stdc++.h>
using namespace std;
int read()
{
	char c=getchar();
	int f=1,x=0;
	while(!isdigit(c))//c<48||c>57
	{
		if(c==45)//c=='-'
			f=-1;
		c=getchar();
	}
	while(isdigit(c))
	{
		x=(x<<3)+(x<<1)+(c^48);
		c=getchar();
	}
	return f*x;
}
void write(int x)
{
	if(x==0)
	{
		putchar(48);
		return ;
	}
	if(x<0)
		putchar(45),x=-x;
	int l=0;
	char _c[25];
	while(x)
	{
		_c[++l]=(x%10)^48;
		x/=10;
	}
	for(int i=l;i>=1;i--)
	{
		putchar(_c[i]);
	}
	return ;
}
int solve1()//快读快输 
{
	int n=read(),a,b=0;
	for(int i=1;i<=n;i++)
	{
		a=read();
		b^=a;
	}
	for(int i=1;i<=n;i++)
	{
		write(b);
		putchar(10);
	}
	return 0;
}
int solve2()//cin、cout解除捆绑和同步 
{
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	int n,a,b=0;
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>a;
		b^=a;
	}
	for(int i=1;i<=n;i++)
		cout<<b<<'\n';
	return 0;
}
int main()
{
	return solve1();//618ms
//	return solve2();//496ms
}

离散化

注：此代码并非解题代码

#include <bits/stdc++.h>
using namespace std;
const int N=100001;
int n,a[N];
vector<int>lsh;
void Discretization()//离散化
{
	for(int i=1;i<=n;i++)
	{
		lsh.push_back(a[i]);
	}
	sort(lsh.begin(),lsh.end());
	lsh.erase(unique(lsh.begin(),lsh.end()),lsh.end());
	for(int i=1;i<=n;i++)
	{
		a[i]=lower_bound(lsh.begin(),lsh.end(),a[i])-lsh.begin();//最小数字从0开始 
	}
}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
	}
	Discretization();
	for(int i=1;i<=n;i++)
	{
		printf("%d ",a[i]);
	}
	return 0;
}

数学

埃氏筛法

#include <bits/stdc++.h>
using namespace std;
int n,q;
bool book[100000001];
vector<int>pr;
void prime()
{
	book[0]=book[1]=1;
	for(int i=2;i<=n;i++)
	{
		if(book[i]==0)
		{
			pr.push_back(i);
			for(int j=i*2;j<=n;j+=i)
				book[j]=1;
		}
	} 
}
int main()
{
	scanf("%d%d",&n,&q);
	prime();
	int a;
	for(int i=1;i<=q;i++)
	{
		scanf("%d",&a);
		printf("%d\n",pr[a-1]);
	}
	return 0;
}

线性筛法

#include <bits/stdc++.h>
using namespace std;
int n,q;
bool book[100000001];
vector<int>pr;
void prime()
{
	book[0]=book[1]=1;
	for(int i=2;i<=n;i++)
	{
		if(book[i]==0)
		{
			pr.push_back(i);
		}
		for(int j=0;j<pr.size();j++)
		{ 
			if(i*pr[j]>n)
				break;
			book[i*pr[j]]=1;
			if(i%pr[j]==0)
				break;/*保证一个数只被它的最小质因数筛掉 
			满足条件时，可证明：
			设pr[s]<pr[j]<pr[l](s<j<l) 
			1.i的最小质因数是pr[j](如果是之前的质数，早就break了)
			2.i*pr[s]的最小质因数是pr[s](如果是更小的质数，在那时会因为1结论break) 
			3.i*pr[l]的最小值质因数是pr[j](i的最小质因数是pr[j]，pr[j]<pr[l],所以成立) 
			*/
		}
	} 
}
int main()
{
	scanf("%d%d",&n,&q);
	prime();
	int a;
	for(int i=1;i<=q;i++)
	{
		scanf("%d",&a);
		printf("%d\n",pr[a-1]);
	}
	return 0;
}

快速幂

#include <bits/stdc++.h>
using namespace std;
long long my_pow(long long a,int b,long long mod)//计算a^b%mod的值 
{
	long long ans=1;
	while(b)
	{
		if(b&1)ans=(ans*a)%mod;
		b>>=1;
		a=(a*a)%mod;
	}
	return ans;
}
int main()
{
	long long a,mod;
	int b;
	scanf("%lld%d%lld",&a,&b,&mod);
	printf("%lld^%d mod %lld=%lld",a,b,mod,my_pow(a,b,mod));
	return 0;
}

图论

图的存储

注：此代码并非解题代码

#include <bits/stdc++.h>
using namespace std;
const int N=1001,M=100001;
//法1：邻接矩阵 
int e1[N][N];//存储边权值，没有可用1代替 
//法2：邻接表
int head[N],nxt[2*M],v[2*M],w[2*M],d[N],tot1=0;//无向图需2*M的空间 
void add(int a,int b,int w1)
{
	v[++tot1]=b;
	w[tot1]=w1;//边权值，没有可不写
	nxt[tot1]=head[a];
	head[a]=tot1;
	d[a]++;//求度数 
	return ;
}
//法3：vector
struct node2
{
	int v;
	int w;//边权值，没有可不写 
	node2(int v,int w):v(v),w(w){}
};
vector<node2> e2[N];
//法4：边集数组
struct node3
{
	int u,v;
	int w;//边权值，没有可不写 
	node3(int u,int v,int w):u(u),v(v),w(w){}
	node3():u(0),v(0),w(0){}
}e3[2*M];//无向图需2*M的空间 
int tot2=0;
int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	int a,b;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d",&a,&b);
		//领接矩阵存图 
		e1[a][b]=1;//有向图只用存这一条边
		e1[b][a]=1;
		//邻接表存图 
		add(a,b,1);//有向图只用存这一条边
		add(b,a,1);
		//vector存图
		e2[a].push_back(node2(b,1));//有向图只用存这一条边
		e2[b].push_back(node2(a,1));
		//边集数组存图
		e3[++tot2]=node3(a,b,1);//有向图只用存这一条边
		e3[++tot2]=node3(b,a,1);
	}
	//邻接矩阵输出 
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
			printf("%d ",e1[i][j]);
		printf("\n"); 
	}
	//领接表输出
	for(int i=1;i<=n;i++)
	{
		printf("%d ",d[i]);//输出度数 
		for(int j=head[i];j;j=nxt[j])
		{
			printf("%d ",v[j]);
		}
		printf("\n");
	} 
	//vector输出
	for(int i=1;i<=n;i++)
	{
		printf("%d ",e2[i].size());//输出度数
		for(int j=0;j<e2[i].size();j++)
		{
			printf("%d ",e2[i][j].v);
		}
		printf("\n");
	}
	//边集数组输出
	for(int i=1;i<=tot2;i++)
	{
		printf("%d %d %d\n",e3[i].u,e3[i].v,e3[i].w);
	}
	return 0;
}

dijkstra

普通的dijkstra

//O(n^2)
#include <bits/stdc++.h>
using namespace std;
struct node
{
	int v,w;
	node(int v,int w):v(v),w(w){}
};
int n,m,s,dis[100001],book[100001];
vector<node>e[100001];
int main()
{
	scanf("%d%d%d",&n,&m,&s);
	int u,v,w;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&u,&v,&w);
		e[u].push_back(node(v,w));
	}
	memset(dis,0x3f,sizeof(dis));
	dis[s]=0;
	for(int i=1;i<=n;i++)
	{
		int minn=0x3f3f3f3f,minp;
		for(int j=1;j<=n;j++)
		{
			if((!book[j])&&dis[j]<minn)
			{
				minn=dis[j];
				minp=j;
			}
		}
		if(minn==0x3f3f3f3f)
			break;
		book[minp]=1;
		for(int j=0;j<e[minp].size();j++)
		{
			if(dis[e[minp][j].v]>dis[minp]+e[minp][j].w&&(!book[e[minp][j].v]))
			{
				dis[e[minp][j].v]=dis[minp]+e[minp][j].w;
			}
		}
	}
	for(int i=1;i<=n;i++)
	{
		if(dis[i]==0x3f3f3f3f)
			printf("2147483647 ");
		else
			printf("%d ",dis[i]);
	}
	return 0;
}

堆优化的dijkstra

//O(n*log2n)
#include <bits/stdc++.h>
using namespace std;
struct node
{
	int v,w;
	node(int v,int w):v(v),w(w){}
};
struct node2
{
	int d,p;
	node2(int d,int p):d(d),p(p){}
};
bool operator<(node2 x,node2 y)
{
	return x.d>y.d;
}
int n,m,s,dis[100001],book[100001];
vector<node>e[100001];
int main()
{
	scanf("%d%d%d",&n,&m,&s);
	int u,v,w;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&u,&v,&w);
		e[u].push_back(node(v,w));
	}
	memset(dis,0x3f,sizeof(dis));
	dis[s]=0;
	priority_queue<node2>pq;
	pq.push(node2(dis[s],s));
	while(!pq.empty())
	{
		int tp=pq.top().p;
		pq.pop();
		if(book[tp])continue;
		book[tp]=1;
		for(int j=0;j<e[tp].size();j++)
		{
			if(dis[e[tp][j].v]>dis[tp]+e[tp][j].w&&(!book[e[tp][j].v]))
			{
				dis[e[tp][j].v]=dis[tp]+e[tp][j].w;
				pq.push(node2(dis[e[tp][j].v],e[tp][j].v));
			}
		}
	}
	for(int i=1;i<=n;i++)
	{
		if(dis[i]==0x3f3f3f3f)
			printf("2147483647 ");
		else
			printf("%d ",dis[i]);
	}
	return 0;
}

bellman-ford

//O(n*m)
#include <bits/stdc++.h>
using namespace std;
struct node
{
	int u,v,w;
}e[500001];
int n,m,s,dis[100001];
int main()
{
	scanf("%d%d%d",&n,&m,&s);
	int u,v,w;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);
	}
	memset(dis,0x3f,sizeof(dis));
	dis[s]=0;
	bool flag;
	for(int i=1;i<=n-1;i++)//进行n-1轮松弛，每一轮松弛所得到的最短路可经过n-1条边 
	{
		flag=0;
		for(int j=1;j<=m;j++)//用m条边松弛 
		{
			if(dis[e[j].v]>dis[e[j].u]+e[j].w)
			{
				dis[e[j].v]=dis[e[j].u]+e[j].w;
				flag=1;
			} 
		} 
		if(!flag)
			break;//松弛不了了直接退出 
	}
	for(int i=1;i<=n;i++)
	{
		if(dis[i]==0x3f3f3f3f)
			printf("2147483647 ");
		else
			printf("%d ",dis[i]);
	}
	return 0;
}

SPFA(队列优化的bellman-ford)

//最坏O(n*m)
#include <bits/stdc++.h>
using namespace std;
struct node
{
	int v,w;
	node(int v,int w):v(v),w(w){}
};
vector<node> e[100001];
int n,m,s,dis[100001],book[100001];
int main()
{
	scanf("%d%d%d",&n,&m,&s);
	int u,v,w;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&u,&v,&w);
		e[u].push_back(node(v,w));
	}
	memset(dis,0x3f,sizeof(dis));
	dis[s]=0;
	queue<int>q;
	q.push(s);
	book[s]=1;
	while(!q.empty())//只松弛上一轮松弛成功过的点 
	{
		u=q.front(); 
		q.pop();
		book[u]=0;
		for(int j=0;j<e[u].size();j++)//用这个点的出边松弛 
		{
			if(dis[e[u][j].v]>dis[u]+e[u][j].w)
			{
				dis[e[u][j].v]=dis[u]+e[u][j].w;
				if(!book[e[u][j].v])
				{
					q.push(e[u][j].v);
					book[e[u][j].v]=1;
				}
			} 
		} 
	}
	for(int i=1;i<=n;i++)
	{
		if(dis[i]==0x3f3f3f3f)
			printf("2147483647 ");
		else
			printf("%d ",dis[i]);
	}
	return 0;
}

floyd

#include <bits/stdc++.h>
using namespace std;
int n,m,e[101][101];
int main()
{
	scanf("%d%d",&n,&m);
	int u,v,w;
	for(int i=1;i<=n;i++)//一定要初始化 
	{
		for(int j=1;j<=n;j++)
		{
			if(i==j)e[i][j]=0;
			else e[i][j]=0x3f3f3f3f;
		}
	}
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&u,&v,&w);
		e[u][v]=w;
		e[v][u]=w;
	}
	for(int k=1;k<=n;k++)//中转点
	{
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++)
			{
				if(e[i][j]>e[i][k]+e[k][j])
				{
					e[i][j]=e[i][k]+e[k][j];
				}
			}
		} 
	} 
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			printf("%d ",e[i][j]);
		}
		printf("\n");
	} 
	return 0;
}

最小生成树

kurskal

//O((n+m)*log2n)
#include <bits/stdc++.h>
using namespace std;
struct node
{
	int u,v,w;
}e[400001];//双向边，两倍存 
int n,m,f[5001];
bool cmp(node x,node y)
{
	return x.w<y.w;
}
int findf(int x)
{
	if(x==f[x])return x;
	f[x]=findf(f[x]);
	return f[x];
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
	{
		f[i]=i;
	}
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);
	}
	sort(e+1,e+m+1,cmp);
	int cnt=0,sum=0;
	int fu,fv;
	for(int i=1;i<=m;i++)
	{
		fu=findf(e[i].u),fv=findf(e[i].v);
		if(fu!=fv)
		{
			cnt++;
			sum+=e[i].w;
			f[fv]=fu;
		}
	}
	if(cnt<n-1)
		printf("orz");
	else
		printf("%d",sum);
	return 0;
}

prim

普通prim
//O(n^2)
#include <bits/stdc++.h>
using namespace std;
struct node
{
	int v,w;
	node(int v,int w):v(v),w(w){}
};
int n,m,dis[5001],book[5001];
vector<node>e[5001];
int main()
{
	scanf("%d%d",&n,&m);
	int u,v,w;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&u,&v,&w);
		e[u].push_back(node(v,w));
		e[v].push_back(node(u,w)); 
	}
	for(int i=1;i<=n;i++)
		dis[i]=0x3f3f3f3f;
	dis[1]=0;//默认以1号点为根 
	for(int i=1;i<=n;i++)//每轮增加一个节点，共n个 
	{
		int minn=0x3f3f3f3f,minp; 
		for(int j=1;j<=n;j++)
		{
			if(dis[j]<minn&&book[j]==0)
			{
				minn=dis[j];
				minp=j;
			}
		}
		book[minp]=1;
		for(int j=0;j<e[minp].size();j++)
		{
			if(dis[e[minp][j].v]>e[minp][j].w&&book[e[minp][j].v]==0)
			{
				dis[e[minp][j].v]=e[minp][j].w;
			}
		}
	}
	int ans=0;
	for(int i=1;i<=n;i++)
	{
		if(dis[i]==0x3f3f3f3f)
		{
			printf("orz");
			return 0;
		}
		ans+=dis[i];
	}
	printf("%d",ans);
	return 0;
}
堆优化prim
//O(n*log2n)
#include <bits/stdc++.h>
using namespace std;
struct node
{
	int p,di;
	node(int p,int di):p(p),di(di){}
};
int head[5001],nxt[400001],v[400001],w[400001],tot;
int n,m,dis[5001],book[5001];
bool operator<(node x,node y)
{
	return x.di>y.di;
}
void add(int a,int b,int c)
{
	++tot;
	v[tot]=b,w[tot]=c;
	nxt[tot]=head[a];
	head[a]=tot;
}
int main()
{
	scanf("%d%d",&n,&m);
	int a,b,c;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c);
		add(b,a,c);
	}
	memset(dis,0x3f3f3f3f,sizeof(dis));
	int ans=0,cnt=0;
	priority_queue<node>pq;
	dis[1]=0;
	pq.push(node(1,dis[1]));
	while(!pq.empty())
	{
		int u=pq.top().p;
		pq.pop();
		if(book[u])continue;
		book[u]=1;
		ans+=dis[u];
		cnt++;
		for(int i=head[u];i;i=nxt[i])
		{
			if(dis[v[i]]>w[i]&&book[v[i]]==0)
			{
				dis[v[i]]=w[i];
				pq.push(node(v[i],dis[v[i]]));
			}
		}
	}
	if(cnt<n-1)
		printf("orz");
	else
		printf("%d",ans);
	return 0;
}

tarjan

求边双连通分量/割边

#include <bits/stdc++.h>
using namespace std;
const int N=500005,M=4000005;
int n,m;
int dfn[N],low[N],id=0,cutedge[M];
int book[N];
vector<vector<int> >ebc;
//###邻接表###
int head[N],nxt[M],to[M],tot=1;
//小技巧：从2开始存边,通过异或操作可以取反向边（(2n)^1=2n+1,(2n+1)^1=2n） 
void add(int u,int v)
{
	tot++;
	to[tot]=v;
	nxt[tot]=head[u];
	head[u]=tot;
}
//############
void tarjan(int u,int in_edge)//求割边的tarjan
{
	dfn[u]=low[u]=++id;//首次访问时间戳和能通过自己及孩子访问到的最小首访时间戳都初始为下一个时间戳 
	for(int i=head[u];i;i=nxt[i])
	{
		if(dfn[to[i]]==0)//若它的邻接点没有访问过，则它是孩子 
		{
			tarjan(to[i],i);
			//在回溯时，求解割边
			if(dfn[u]<low[to[i]])//对于边u-v，若v不能访问到u的祖先或u自己，则该边为割边
				cutedge[i]=cutedge[i^1]=1;//标记该边及反向边为割边
			low[u]=min(low[u],low[to[i]]);//将孩子的最小访问信息传递给父亲 
		} 
		else if(i!=(in_edge^1))//若该边不是通向u的边，则这是一条返祖边 
		{
			 low[u]=min(low[u],dfn[to[i]]);//把祖先to[i]的信息传递给u 
		}
	} 
	return ;
} 
void dfs(int u,int idd)
{
	book[u]=idd;//标记u点在这个双连通分量中
	ebc.back().push_back(u);//将u点加入到这个双连通分量中 
	for(int i=head[u];i;i=nxt[i])
	{
		if(book[to[i]]||cutedge[i])continue;//如果邻接点已经统计过，或者经过了割边，则不统计入
		dfs(to[i],idd); 
	}
} 
int main()
{
	cin>>n>>m;
	int _u,_v;
	for(int i=1;i<=m;i++)
	{
		cin>>_u>>_v;
		add(_u,_v);
		add(_v,_u);
	}
	for(int i=1;i<=n;i++)//每个点都要走到 
	{
		if(dfn[i]==0)//走过就不走了 
			tarjan(i,0);
	} 
	int ans=0;
	for(int i=1;i<=n;i++)//求取边双连通分量 
	{
		if(book[i]==0)//如果该点还未在一个双连通分量中
		{
			ebc.push_back(vector<int>());//新建一个空的双连通分量 
			dfs(i,++ans);//求取包含这个节点的双连通分量 
		} 
	}
	cout<<ans<<'\n';
	for(int i=0;i<ebc.size();i++)
	{
		cout<<ebc[i].size()<<' ';
		for(int j=0;j<ebc[i].size();j++)
		{
			cout<<ebc[i][j]<<' ';
		}
		cout<<'\n';
	}
	return 0;
}

树论

最近公共祖先

在线算法（倍增）

#include <bits/stdc++.h>
using namespace std;
int n,m,s,deep[500001],t[25][500001],lgn;
vector<int>e[500001];
void dfs(int u,int f,int dp)
{
	deep[u]=dp;
	t[0][u]=f;
	for(int i=0;i<e[u].size();i++)
	{
		if(e[u][i]==f)
			continue;
		dfs(e[u][i],u,dp+1);
	}
}
int lca(int x,int y)
{
	if(deep[x]>deep[y])
		swap(x,y);
	for(int i=lgn;i>=0;i--)
	{
		if(deep[x]<=deep[t[i][y]])
			y=t[i][y];
	}
	if(x==y)
		return x;
	for(int i=lgn;i>=0;i--)
	{
		if(t[i][x]!=t[i][y])
			x=t[i][x],y=t[i][y];
	}
	return t[0][x];
}
int main()
{
	scanf("%d%d%d",&n,&m,&s);
	int u,v;
	for(int i=1;i<=n-1;i++)
	{
		scanf("%d%d",&u,&v);
		e[u].push_back(v);
		e[v].push_back(u);
	}
	dfs(s,s,1);
	lgn=log2(n);
	for(int i=1;i<=lgn;i++)
	{
		for(int j=1;j<=n;j++)
		{
			t[i][j]=t[i-1][t[i-1][j]];
		}
	}
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d",&u,&v);
		printf("%d\n",lca(u,v));
	}
	return 0;
}

数据结构

二叉堆

#include <bits/stdc++.h>
using namespace std;
const int N=1000001;
int tree[N],size=0;
void push(int x)//插入 O(log2n)
{
	tree[++size]=x;
	x=size;
	if(x==1)
		return ;
	int _t;
	//实现最小堆（最大堆只需要变一下符号） 
	while(x!=1&&tree[x]<tree[x/2])
	{
		_t=tree[x];
		tree[x]=tree[x/2];
		tree[x/2]=_t;
		x=x/2;
	}
	return ;
}
void pop_front()//弹出堆顶 O(log2n)
{
	if(!size)
		return ;
	tree[1]=tree[size--];
	int x=1,minn,p,_t;
	while(x*2<=size||x*2+1<=size)
	{
		minn=tree[x];
		if(x*2<=size&&tree[x*2]<minn)
			minn=tree[x*2],p=x*2;
		if(x*2+1<=size&&tree[x*2+1]<minn)
			minn=tree[x*2+1],p=x*2+1;
		if(minn==tree[x])
			return ;
		tree[p]=tree[x];
		tree[x]=minn;
		x=p;
	}
	return ;
} 
inline int top()//询问堆顶 O(1) 
{
	return size?tree[1]:-1;
}
int main()
{
	int n,op,x;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&op);
		if(op==1)
		{
			scanf("%d",&x);
			push(x);
		}
		else if(op==2)
		{
			if(top()!=-1)
				printf("%d\n",top());
		}
		else if(op==3)
		{
			pop_front();
		}
	}
	return 0;
}

线段树

区间查询、区间修改

  • 普通写法
#include <bits/stdc++.h>
using namespace std;
const int N=100005;
long long nums[N];
struct Tree
{
	long long data;
	int l,r;
}tree[4*N];
long long modified[4*N];
void build_tree(long long *num,int l,int r,int x)//建树 
{
	tree[x].l=l;tree[x].r=r;modified[x]=0;
	if(tree[x].l==tree[x].r)
	{
		tree[x].data=num[tree[x].l];//不要写成了num[x]
		return ;
	}
	int mid=(l+r)>>1; 
	build_tree(num,l,mid,x<<1);
	build_tree(num,mid+1,r,x<<1|1);
	tree[x].data=tree[x<<1].data+tree[x<<1|1].data;
	return ;
}
void push_down(int x)
{
	tree[x<<1].data+=(tree[x<<1].r-tree[x<<1].l+1)*modified[x];
	tree[x<<1|1].data+=(tree[x<<1|1].r-tree[x<<1|1].l+1)*modified[x];
	modified[x<<1]+=modified[x];
	modified[x<<1|1]+=modified[x];
	modified[x]=0;
	return ;
} 
void interval_modification(int l,int r,int x,long long modify_number)//区间修改 
{
	if(l<=tree[x].l&&tree[x].r<=r)//不用向下 
	{
		tree[x].data+=(tree[x].r-tree[x].l+1)*modify_number;
		modified[x]+=modify_number;
		return ; 
	}
	push_down(x);//修改时不下方会导致求和错误 
	int mid=(tree[x].l+tree[x].r)>>1;
	if(l<=mid)//修改区间在左半区间有
		 interval_modification(l,r,x<<1,modify_number); 
	if(r>=mid+1)//修改区间在右半区间有
		 interval_modification(l,r,x<<1|1,modify_number); 
	tree[x].data=tree[x<<1].data+tree[x<<1|1].data;
	return ; 
}
long long interval_query(int l,int r,int x)//区间查询 
{
	if(l<=tree[x].l&&tree[x].r<=r)//不用向下 
	{
		return tree[x].data; 
	}
	push_down(x);//下放操作 
	int mid=(tree[x].l+tree[x].r)>>1;
	long long res=0; 
	if(l<=mid)//查询区间在左半区间有
		 res+=interval_query(l,r,x<<1); 
	if(r>=mid+1)//查询区间在右半区间有
		 res+=interval_query(l,r,x<<1|1); 
	return res;
}
int main()
{
	int n,m;
	cin>>n>>m; 
	for(int i=1;i<=n;i++)
	{
		cin>>nums[i];
	}
	build_tree(nums,1,n,1);
	int op,x,y;
	long long k;
	for(int i=1;i<=m;i++)
	{
		cin>>op;
		if(op==1)
		{
			cin>>x>>y>>k;
			interval_modification(x,y,1,k);
		}
		else if(op==2)
		{
			cin>>x>>y;
			cout<<interval_query(x,y,1)<<'\n';
		}
	}
	return 0;
}
  • 模板类写法（本地报错）
#include <bits/stdc++.h>
#define N 100005
using namespace std;
template <typename mytype> class Segment_tree{
private:
	struct Tree{
		mytype data;
		int l,r;
	}tree[4*N];
	mytype modified[4*N];
	void push_down(int x){
		tree[x<<1].data+=(tree[x<<1].r-tree[x<<1].l+1)*modified[x];
		tree[x<<1|1].data+=(tree[x<<1|1].r-tree[x<<1|1].l+1)*modified[x];
		modified[x<<1]+=modified[x];
		modified[x<<1|1]+=modified[x];
		modified[x]=0;
		return ;
	} 
public:
	void build_tree(mytype *num,int l,int r,int x){//建树 
	
		tree[x].l=l;tree[x].r=r;modified[x]=0;
		if(tree[x].l==tree[x].r)
		{
			tree[x].data=num[tree[x].l];//不要写成了num[x]
			return ;
		}
		int mid=(l+r)>>1; 
		build_tree(num,l,mid,x<<1);
		build_tree(num,mid+1,r,x<<1|1);
		tree[x].data=tree[x<<1].data+tree[x<<1|1].data;
		return ;
	}
	void interval_modification(int l,int r,int x,mytype modify_number){//区间修改 
	
		if(l<=tree[x].l&&tree[x].r<=r)//不用向下 
		{
			tree[x].data+=(tree[x].r-tree[x].l+1)*modify_number;
			modified[x]+=modify_number;
			return ; 
		}
		push_down(x);//修改时不下方会导致求和错误 
		int mid=(tree[x].l+tree[x].r)>>1;
		if(l<=mid)//修改区间在左半区间有
			 interval_modification(l,r,x<<1,modify_number); 
		if(r>=mid+1)//修改区间在右半区间有
			 interval_modification(l,r,x<<1|1,modify_number); 
		tree[x].data=tree[x<<1].data+tree[x<<1|1].data;
		return ; 
	}
	mytype interval_query(int l,int r,int x){//区间查询 
	
		if(l<=tree[x].l&&tree[x].r<=r)//不用向下 
		{
			return tree[x].data; 
		}
		push_down(x);//下放操作 
		int mid=(tree[x].l+tree[x].r)>>1;
		mytype res=0; 
		if(l<=mid)//查询区间在左半区间有
			 res+=interval_query(l,r,x<<1); 
		if(r>=mid+1)//查询区间在右半区间有
			 res+=interval_query(l,r,x<<1|1); 
		return res;
	}
};
long long nums[N];
int main()
{
	int n,m;
	cin>>n>>m; 
	for(int i=1;i<=n;i++)
	{
		cin>>nums[i];
	}
	Segment_tree<long long>stree;
	stree.build_tree(nums,1,n,1);
	int op,x,y;
	long long k;
	for(int i=1;i<=m;i++)
	{
		cin>>op;
		if(op==1)
		{
			cin>>x>>y>>k;
			stree.interval_modification(x,y,1,k);
		}
		else if(op==2)
		{
			cin>>x>>y;
			cout<<stree.interval_query(x,y,1)<<'\n';
		}
	}
	return 0;
}

树状数组

单点修改，区间查询

  • 普通写法
#include <bits/stdc++.h>
using namespace std;
#define lowbit(x) ((x)&(-x))
#define N 500005
int tree[N],n;
void build(int *num,int x)
{
	int lb;
	n=x;
	for(int i=1;i<=n;i++)
	{
		tree[i]+=num[i];
		lb=i+lowbit(i);
		if(lb<=n)tree[lb]+=tree[i];
	}
	return ;
}
void Single_point_modification(int x,int modify_number)//单点修改 
{
	for(;x<=n;x+=lowbit(x))
		tree[x]+=modify_number;
	return ;
}
int Prefix_query(int x)//前缀查询 
{
	int sum=0;
	for(;x;x-=lowbit(x))
		sum+=tree[x];
	return sum;
}
int Interval_query(int l,int r)//区间查询 
{
	return Prefix_query(r)-Prefix_query(l-1);
}
int nums[N];
int main()
{
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	{
		cin>>nums[i];
	}
	build(nums,n);
	int op,x,y;
	for(int i=1;i<=m;i++)
	{
		cin>>op>>x>>y;
		if(op==1)
		{
			Single_point_modification(x,y);
		}
		else if(op==2)
		{
			cout<<Interval_query(x,y)<<'\n';
		}
	}
	return 0;
}
  • 模板类写法
#include <bits/stdc++.h>
using namespace std;
#define lowbit(x) ((x)&(-x))
#define N 500005
template<typename mytype> class Binary_Index_Tree{
private:
	mytype tree[N];
	int n;
public:
	void build(mytype *num,int x)
	{
		int lb;
		n=x;
		memset(tree,0,sizeof(tree));
		for(int i=1;i<=n;i++)
		{
			tree[i]+=num[i];
			lb=i+lowbit(i);
			if(lb<=n)tree[lb]+=tree[i];
		}
		return ;
	}
	void Single_point_modification(int x,mytype modify_number)//单点修改 
	{
		for(;x<=n;x+=lowbit(x))
			tree[x]+=modify_number;
		return ;
	}
	mytype Prefix_query(int x)//前缀查询 
	{
		mytype sum=0;
		for(;x;x-=lowbit(x))
			sum+=tree[x];
		return sum;
	}
	mytype Interval_query(int l,int r)//区间查询 
	{
		return Prefix_query(r)-Prefix_query(l-1);
	}
};
int nums[N];
int main()
{
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	{
		cin>>nums[i];
	}
	Binary_Index_Tree<int>bitree;
	bitree.build(nums,n);
	int op,x,y;
	for(int i=1;i<=m;i++)
	{
		cin>>op>>x>>y;
		if(op==1)
		{
			bitree.Single_point_modification(x,y);
		}
		else if(op==2)
		{
			cout<<bitree.Interval_query(x,y)<<'\n';
		}
	}
	return 0;
}

区间修改，单点查询

  • 模板类写法
#include <bits/stdc++.h>
using namespace std;
#define lowbit(x) ((x)&(-x))
#define N 500005
template<typename mytype> class Binary_Index_Tree{
private:
	mytype tree[N];
	int n;
public:
	void build(mytype *num,int x)
	{
		int lb;
		n=x;
		memset(tree,0,sizeof(tree));
		for(int i=1;i<=n;i++)
		{
			tree[i]+=num[i];
			lb=i+lowbit(i);
			if(lb<=n)tree[lb]+=tree[i];
		}
		return ;
	}
	void Single_point_modification(int x,mytype modify_number)
	{
		for(;x<=n;x+=lowbit(x))
			tree[x]+=modify_number;
		return ;
	}
	mytype Prefix_query(int x)
	{
		mytype sum=0;
		for(;x;x-=lowbit(x))
			sum+=tree[x];
		return sum;
	}
	mytype Interval_query(int l,int r)
	{
		return Prefix_query(r)-Prefix_query(l-1);
	}
};
int nums[N];
int main()
{
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	{
		cin>>nums[i];
	}
	nums[n+1]-=nums[n];
	for(int i=n;i>=1;i--)
	{
		nums[i]-=nums[i-1];//技巧：使用差分,转化操作 
	}
	Binary_Index_Tree<int>bitree;
	bitree.build(nums,n+1);
	int op,x,y,k;
	for(int i=1;i<=m;i++)
	{
		cin>>op;
		if(op==1)
		{
			cin>>x>>y>>k;
			//差分，把x-y增加k （x及以后的所有增加k，(y+1)及以后的减少k还原） 
			bitree.Single_point_modification(x,k);
			bitree.Single_point_modification(y+1,-k);
		}
		else if(op==2)
		{
			cin>>x;
			cout<<bitree.Prefix_query(x)<<'\n';//差分的前缀和等于原数 
		}
	}
	return 0;
}

算法模板正在更新，敬请期待

mike_code
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
ACM算法模板总结（分类详细版）
wait
02-27 1万+
本文模均引用于y总的算法模板，网址：AcWing (本文属于持续更新ing.......)
查找算法模板总结
luolan9611的博客
02-16 406
重要查找算法的模板总结：按照复习顺序持续填坑中… 二分查找： 递归版本： 在这里插入代码片 非递归版本：
常用算法代码模板总结
一条咸鱼的博客
12-29 2570
去除数组中重复的元素（双指针） public static void main(String args[]) { int[] nums = { 1, 1, 2, 2, 2, 3, 4, 4, 5, 6, 7 }; int j = 0; for (int i = 0; i < nums.length; i++) {//去除数组当中重复的元素 if (i == 0 || nums[i] != nums[i - 1]) nums[j++] = nums[i]; }
算法模板
Vison307的博客
05-09 280
网络流 最大流EK算法 #include<bits/stdc++.h> using namespace std; const int N = 1e4+7;//节点数 const int M = 1e5+7;//边数 const int INF = 0x4f4f4f4f; int n, m, s, t;//节点数，边数，源点，汇点 struct Node{ int to;//这...
基础算法模板
qq_48290779的博客
02-18 853
基础算法模板
部分常见算法模板总结
01-09
包含高精计算、快速幂、背包问题、区间DP、并查集、树状结构等算法模板
常用算法模板_C++.zip
04-27
常用算法模板_C++.zip AC自动机，Dijkstra，Floyd，GCD，KMP，KMP扩展，Kruskal，LCM，LCS，LIS，Prim，SPFA，埃氏筛，背包，并查集，多边形面积，二分搜索，高精度加法，高精度阶乘，级角排序，进制转换，快速幂，...
算法模板1
08-08
【算法模板1】：在编程竞赛或算法设计中，算法模板是解决一类问题的通用框架。这可能包括数据结构如线段树、树状数组，或者特定问题的解法如DFS（深度优先搜索）、FFT（快速傅里叶变换）。算法模板帮助程序员快速地...
acm 算法及模板总结
01-21
以下是对标题“acm算法及模板总结”中涉及的几个关键知识点的详细解释： 1. **ACM算法**： - **排序算法**：快速排序、归并排序、堆排序等，常用于处理比赛中的数组和序列问题。 - **搜索算法**：深度优先搜索...
kuangbin的ACM模板（新）_ACM模板_ACM算法总结_
09-29
《kuangbin的ACM模板（新）》是针对ACM（国际大学生程序设计竞赛，International Collegiate Programming Contest）竞赛的一份详细算法总结。这份资料旨在帮助参赛者系统地理解和掌握ACM比赛所需的各类核心算法，...
Held-Karp算法的C++代码
m0_61862494的博客
07-19 113
Held-Karp算法是动态规划的一种应用，用于解决旅行商问题 (TSP)。该算法通过记录部分路径的最小成本来避免重复计算，从而有效地降低计算复杂度。Held-Karp算法使用一个状态压缩动态规划表。表示从起点出发，访问过所有由。表示的集合中的节点，并以节点。结束的最小路径长度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 238
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
代码随想录学习 54day 图论 A star算法
qq_40445763的博客
07-17 461
【代码】代码随想录学习 54day 图论 A star算法。
插入和选择排序
c23856的博客
07-20 209
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
【JavaScript 算法】栈与队列：解决括号匹配问题
Allen-
07-17 566
在编程中，括号匹配问题是一类常见的算法题，通常用于验证括号的正确性，即检查括号是否成对出现且嵌套正确。栈（Stack）是一种非常适合解决括号匹配问题的数据结构。本文将详细介绍如何使用栈来解决括号匹配问题的原理、实现及其应用。
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 217
完全二叉树的节点个数-递归
【java】力扣 H指数
qq_55846232的博客
07-17 286
java 力扣 H指数
【算法】算法模板
qq_44765647的博客
07-19 268
LeetCode网站中学习算法的过程中使用到并总结的算法模板算法模板 数组算法模板，字符串算法模板，列表算法模板，数学算法模板，树算法模板，图算法模板，动态规划算法模板
python实现图像缩放算法
最新发布
qq_42568323的博客
07-20 251
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
ACM算法模板总结：大数、搜索、最短路等
这篇文档是一个针对ACM竞赛的算法模板集合，包含了多种常用算法的C/C++实现。它旨在帮助初学者理解和记忆常见问题的解决策略，并提供可复用的代码模板。文档涵盖的算法范围广泛，包括大数操作、二分查找、枚举排列、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

mike_code

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值