C++ 模板集 - 不定期更新

文章目录

- 01背包
- 完全背包
- 动态规划
- 区间动态规划
- DFS - 栈
- 链式前项星
- 图论 dijkstra算法 (邻接矩阵)
- 图论 dijkstra算法 - 堆优化 (小根堆)
- 图论 dijkstra算法 - 堆优化 (大根堆-修复中)
- 最短路 - SPFA
- 最短路 - Floyd
- 最小生成树 - Kruskal
- 最小生成树 - Prim
- 快读
- 拓扑排序
- 高精度 - 加法 (整数)
- 高精度 - 减法 (整数)
- 高精度 - 乘法（整数）
- 快排模板
- 欧式筛素数

01背包

#include<bits/stdc++.h>
using namespace std;
int a[31],b[31],d[31][31];
int main()
{
	int m,n;
	scanf("%d%d",&m,&n);
	for(int i=1;i<=n;i++) scanf("%d%d",&a[i],&b[i]);
	for(int i=1;i<=n;i++)
		for(int j=m;j>a[i];j--)
			d[i][j]=max(d[i-1][j-a[i]]+b[i],d[i-1][j]);
	printf("%d",d[n][m]);
	return 0;
}

完全背包

#include<bits/stdc++.h>
using namespace std;
int a[1001],b[1001];
long long d[100001];
int main()
{
	int n,m;
	scanf("%d%d",&m,&n);
	for(int i=1;i<=n;i++) scanf("%d%d",&a[i],&b[i]);
	for(int i=1;i<=n;i++)
		for(int j=a[i];j<=m;j++)
			d[j]=max(d[j],d[j-a[i]]+b[i]);
	printf("max=%d",d[m]);
	return 0;
}

动态规划

#include<bits/stdc++.h>
using namespace std;
int d[200001];
int main()
{
	int n,a,maxn=-1;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a;
		d[i]=max(d[i-1]+a,a);
		maxn=max(maxn,d[i]);
	}
	cout<<maxn<<endl;
	return 0;
}

区间动态规划

#include<bits/stdc++.h>
using namespace std;
int sum[301],f[301][301];
int main()
{
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d",&sum[i]);
		sum[i]+=sum[i-1];
	}
	for(int i=2;i<=n;i++)
		for(int j=1;i+j-1<=n;j++){
			int r=i+j-1;
			f[j][r]=0x3f3f3f3f;
			for(int k=j;k<=r-1;k++)
				f[j][r]=min(f[j][r],f[j][k]+f[k+1][r]);
			f[j][r]+=sum[r]-sum[j-1];
		}
	printf("%d",f[1][n]);
	return 0;
}

DFS - 栈

先将要计算的部分压入栈。
每次弹出栈顶元素，进行操作处理，再将需要递归处理的部分（ $rec u rs i v e$ $c a se$ ）压入栈。
重复 $2$ ，直到栈为空。

struct item{
	int index;
    int sum;
};
void stack(){
    //node 包括子段 
    stack<item> stack;
    item s;
    stack.push(s);
    while(stack.size()>0){
        item c=stack.pop();
        if(c.index<=10){
            item c1,c2;
            c1.index=c.index+1;
            c1.sum=c.sum;
            stack.push(c1);
            c2.index=c.index+1;
            c2.sum=c.sum+a[c.index];
            stack.push(c2);
        }
    }
}

链式前项星

#include<bits/stdc++.h>
using namespace std;
int n,m,cnt=0,h[1001];
struct node{
	int to,nxt,w;
}e[2005];
void add(int u,int v,int w){
	e[++cnt].w=w;
	e[cnt].to=v;
	e[cnt].nxt=h[u];
	h[u]=cnt;
}
int main()
{
	scanf("%d",&n,&m);
	for(int i=1,a,b,c;i<=m;i++){
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c);
	}
	return 0;
}

图论 dijkstra算法 (邻接矩阵)

#include<bits/stdc++.h>
using namespace std;
int n,m,a,b,c,minn;
int so[3005][3005];
int dist[3005];
bool v[3005];
void d(int x){
	for(int i=1;i<=n;i++){
		dist[i]=so[x][i];
	}
	v[x]=true;
	dist[x]=0;
	for(int i=1;i<=n;i++){
		int k=0;
		minn=0x3f3f3f3f;
		for(int j=1;j<=n;j++){
			if(v[j]==false&&dist[j]<minn){
				minn=dist[j];
				k=j;
			}
		}
		v[k]=true;
		for(int j=1;j<=n;j++){
			if(v[j]==false&&minn+so[k][j]<dist[j]){
				dist[j]=minn+so[k][j];
			}
		}
	}
}
int main()
{
	cin>>n>>m;
	memset(so,0x3f,sizeof(so));
	for(int i=1;i<=m;i++){
		cin>>a>>b>>c;
		so[a][b]=c;
		so[b][a]=c;
	}
	d(1);
	cout<<dist[n]<<endl;
	return 0;
}

图论 dijkstra算法 - 堆优化 (小根堆)

#include<bits/stdc++.h>
using namespace std;
inline int read(){
    int x;char ch;
    while(true){
        ch=getchar();
        if(ch>='0'&&ch<='9') break;
    }x=ch-'0';
    while(true){
        ch=getchar();
        if(ch<'0'||ch>'9') break;
        x=x*10+ch-'0';
    }return x;
}
int n,m,cnt=0;
bool vis[100002];
int h[100002],dist[100002];
struct node{
    int to,nxt,w;
}e[200002];
void add(int u,int v,int w){
	e[++cnt].w=w,e[cnt].to=v;
    e[cnt].nxt=h[u],h[u]=cnt;
}
struct cmp{
    bool operator()(int a,int b){
        return dist[a]>dist[b];
    }
};
priority_queue<pair<int,int> > q;
void d(int x){
    memset(dist,0x3f,sizeof(dist));
    memset(vis,0,sizeof(vis));
    dist[x]=0;
    q.push(make_pair(0,1));
    while(q.size()){
        int u=q.top().second;
        q.pop();
        if(vis[u]) continue;
        vis[u]=1;
        for(int i=h[u];i;i=e[i].nxt){
            int v=e[i].to;
            if(dist[v]>dist[u]+e[i].w){
                dist[v]=dist[u]+e[i].w;
                q.push(make_pair(-dist[v],v));
            }
        }
    }
}
int main()
{
    n=read(),m=read();
    for(int i=1,a,b,c;i<=m;i++){
        a=read(),b=read(),c=read();
        add(a,b,c);add(b,a,c);
    }
    d(1);
    printf("%d",dist[n]);
    return 0;
}

图论 dijkstra算法 - 堆优化 (大根堆-修复中)

#include<bits/stdc++.h>
using namespace std;
int n,m,cnt=0;
int h[100001];
int dist[100001];
bool vis[100001];
struct node{
	int to,nxt,w;
}e[200001];
void add(int u,int v,int w){
	e[++cnt].w=w;
	e[cnt].to=v;
	e[cnt].nxt=h[u];
	h[u]=cnt;
}
struct cmp{
	bool operator()(int a,int b){
		return dist[a]>dist[b];
	}
};
priority_queue<int,vector<int>,cmp> q;
void d(int x){
	memset(dist,0x3f,sizeof dist);
	memset(vis,0,sizeof vis);
	dist[x]=0;
	q.push(x);
	while(!q.empty()){
		int u=q.top();
		q.pop();
		if(vis[u]) continue;
		vis[u]=1;
		for(int i=h[u];i;i=e[i].nxt){
			int v=e[i].to;
			if(!vis[v]){
				if(dist[u]+e[i].w<dist[v]){
					dist[v]=dist[u]+e[i].w;
					q.push(v);
				}
			}
		}
	}
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1,a,b,c;i<=m;i++){
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c);
		add(b,a,c);
	}
	d(1);
	printf("%d",dist[n]);
	return 0;
}

最短路 - SPFA

#include<bits/stdc++.h>
using namespace std;
int n,m,cnt=0;
int dist[100005];
int q[100005];
int h[100005];
bool so[100005]; 
struct node{
	int w;
	int to;
	int nxt;
}e[200005];
void add(int u,int v,int w){
	cnt++;
	e[cnt].w=w;
	e[cnt].to=v;
	e[cnt].nxt=h[u];
	h[u]=cnt;
}
void spfa(int l){
	memset(dist,0x3f,sizeof(dist));
	memset(so,0,sizeof(so));
	dist[l]=0;
	int tail=0,head=0;
	tail++;
	q[tail]=l;
	so[l]=true;
	while(head!=tail){
		head++;
		if(head>n) head=1;
		int u=q[head];
		so[u]=false;
		for(int i=h[u];i;i=e[i].nxt){
			int v=e[i].to;
			if(dist[v]>dist[u]+e[i].w&&e[i].w>0){
				dist[v]=dist[u]+e[i].w;
				if(so[v]==false){
					tail++;
					if(tail>n){
						tail=1;
					}
					q[tail]=v;
					so[v]=true; 
				}
			}
		}
	} 
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1,a,b,c;i<=m;i++){
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c);
		add(b,a,c);
	}
	spfa(1);
    printf("%d",dist[n]);
	return 0;
}

最短路 - Floyd

#include<bits/stdc++.h>
using namespace std;
int n,m,dist[105][105];
void floyd(){
	memset(dist,0x3f,sizeof dist);
	for(int k=1;k<=n;k++)
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++){
				if(k==i||k==j||j==i) continue;
				dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j]);
			}
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1,a,b;i<=m;i++){
		scanf("%d%d",&a,&b);
		dist[a][b]=1;
	}
	floyd();
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			printf("%d ",dist[i][j]);
		}
		printf("\n");
	}
	return 0;
}

最小生成树 - Kruskal

#include<bits/stdc++.h>
using namespace std;
struct node{
	int to,nxt,w;
}e[200005];
int f[100005];
int find(int x){
	if(x==f[x]) return x;
	else return f[x]=find(f[x]);
}
bool cmp(node x,node y){
	return x.w<y.w;
}
int main()
{
	int n,m,cnt=0,c=0;
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++)
		scanf("%d%d%d",&e[i].to,&e[i].nxt,&e[i].w);
	sort(e+1,e+m+1,cmp);
	for(int i=1;i<=n;i++) f[i]=i;
	for(int i=1;i<=m;i++){
		int k=find(e[i].to),l=find(e[i].nxt);
		if(k!=l) f[k]=l,cnt+=e[i].w,c++;
	}
	if(c==n-1) printf("%d",cnt);
	else printf("-1");
	//输出最小生成树上的边的边权和，如果不存在，输出-1
	return 0;
}

最小生成树 - Prim

#include<bits/stdc++.h>
using namespace std;
bool vi[105];
int n,a[105][105],dist[105];
void prim(){
	dist[1]=0;
	for(int i=1;i<=n-1;i++){
		int k=0;
		for(int j=1;j<=n;j++)
			if(!vi[j]&&(k==0||dist[j]<dist[k])) k=j;
		vi[k]=true;
		for(int j=1;j<=n;j++)
			if(!vi[j]) dist[j]=min(dist[j],a[k][j]);
	}
}
int main()
{
	memset(a,0x3f,sizeof a);
	memset(dist,0x3f,sizeof dist);
	for(int i=1;i<=n;i++) a[i][i]=0;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			scanf("%d",&a[i][j]);
	prim();
	int cnt=0;
	for(int i=1;i<=n;i++) cnt+=dist[i];
	printf("%d",cnt);
	//输出最小生成树的长度
	return 0;
}

快读

inline int read(){
	register int x=1,ans=0;register char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-') x=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){ans=(ans<<3)+(ans<<1)+ch-48;ch=getchar();}
	return x*ans;
}

拓扑排序

#include<bits/stdc++.h>
using namespace std;
struct node{
	int to;
	int nxt;
}e[10001];
int n,m,cnt=0;
int a[101][101];
int in[10001],h[10001];
queue<int> q;
void add(int u,int v){
	cnt++;
	e[cnt].to=v;
	e[cnt].nxt=h[u];
	h[u]=cnt;
}
void d(){
	for(int i=1;i<=n;i++)
		if(in[i]==0) q.push(i);
	while(!q.empty()){
		int x=q.front();
		printf("%d ",x);
		for(int i=h[x];i!=-1;i=e[i].nxt){
			int v=e[i].to;
			in[v]--;
			if(in[v]==0) q.push(v);
		}
		q.pop();
	}
}
int main()
{
	memset(h,-1,sizeof h);
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++){
		int x,y;
		scanf("%d%d",&x,&y);
		add(x,y);
		in[y]++;
	}
	d();
	return 0;
}

高精度 - 加法 (整数)

#include<bits/stdc++.h>
using namespace std;
int main()
{
	char str[502],ch[502];
    scanf("%s %s",str,ch);
    int lena=strlen(str),lenb=strlen(ch),len=max(lena,lenb);
	int a[501]={0},b[501]={0},c[501]={0};
    for(int i=0;i<lena;i++) a[i]=str[lena-i-1]-'0';
    for(int i=0;i<lenb;i++) b[i]=ch[lenb-i-1]-'0';
	for(int i=0;i<len;i++)
		c[i]+=a[i]+b[i],c[i+1]=c[i]/10,c[i]%=10;
	if(c[len]) len++;
    for(int i=len-1;i>=0;i--) printf("%d",c[i]);
    return 0;
}

高精度 - 减法 (整数)

#include<cstdio>
#include<string.h>
using namespace std;
int main()
{
    char str[10002],ch[10002],tmp[10002];
    scanf("%s %s",str,ch);
    int lena=strlen(str),lenb=strlen(ch);
    if(lena<lenb||(lena==lenb&&strcmp(str,ch)<0)){
        printf("-");
        strcpy(tmp,str);
        strcpy(str,ch);
        strcpy(ch,tmp);
        lena=strlen(str),lenb=strlen(ch);
    }
    int a[10001]={0},b[10001]={0},c[10001]={0};
    for(int i=0;i<lena;i++) a[i]=str[lena-i-1]-'0';
    for(int i=0;i<lenb;i++) b[i]=ch[lenb-i-1]-'0';
    for(int i=0;i<lena;i++){
        if(a[i]<b[i]) a[i+1]--,a[i]+=10;
        c[i]=a[i]-b[i];
    }
    for(int i=lena-1;i>=0;i--)
        if(c[i]==0 && lena>1) lena--;
        else break;
    for(int i=lena-1;i>=0;i--) printf("%d", c[i]);
    return 0;
}

高精度 - 乘法（整数）

#include<iostream>
#include<string.h>
using namespace std;
char str[2100],ch[2100];
int a[2100],b[2100],c[2100];
int main()
{
	scanf("%s\n%s",&str,&ch);
	a[0]=strlen(str),b[0]=strlen(ch);
	for(int i=1;i<=a[0];i++) a[i]=str[a[0]-i]-48;
	for(int i=1;i<=b[0];i++) b[i]=ch[b[0]-i]-48;
	for(int i=1;i<=a[0];i++)
		for(int j=1;j<=b[0];j++)
			c[i+j-1]+=a[i]*b[j];
	int len=a[0]+b[0];
	for(int i=1;i<len;i++)
		if(c[i]>9){
			c[i+1]+=c[i]/10;
			c[i]%=10;
		}
	while(c[len]==0&&len>1) len--;
	for(int i=len;i>=1;i--)
		printf("%d",c[i]);
    return 0;
}

快排模板

void quick_sort(int s[],int l,int r){
    if(l<r){
        //swap(s[l],s[(l+r)/2]);
		//将中间的这个数和第一个数交换 
        int i=l,j=r,x=s[l];
        while(i<j){
        	//从右向左找第一个小于x的数 
            while(i<j&&s[j]>=x)  j--;  
            if(i<j) s[i++]=s[j];
            //从左向右找第一个大于等于x的数 
            while(i<j&&s[i]<x) i++;  
            if(i<j) s[j--]=s[i];
        }
        s[i]=x;
        quick_sort(s,l,i-1);
        quick_sort(s,i+1,r);
    }
}

欧式筛素数

#include<bits/stdc++.h>
using namespace std;
bool a[50000007];
int main()
{
	int n;scanf("%d",&n);
	a[0]=a[1]=1;
	for(int i=2;i<=sqrt(n);i++)
		if(a[i]==0)
			for(int j=i;i*j<=n;j++) a[i*j]=1;
	for(int i=3;i<=n-2;i+=2)
		if(!a[i]&&!a[i+2]) printf("%d %d\n",i,i+2);
	return 0;
}