模板

最小生成树克鲁斯卡尔算法和并查集算法：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
//并查集和克鲁斯卡尔最小生成树模板
struct lujing
{
	int x;
	int y;
	int l;
} lj[100]; //用来存储两节点之间的距离
int root[100],rooth[100];//用来存根还有根深
int found(int x)//寻找根节点
{
	int xroot=x;
	while(root[xroot]!=0)
		xroot=root[xroot];
	return xroot;
}
int lian(int x,int y)//判断这两个点是否在同一颗树里
{
	int xroot=found(x);
	int yroot=found(y);
	if(xroot==yroot)//如果两节点在同一棵树中，返回1
		return 1;
	if(rooth[xroot]>rooth[yroot])//判断这两个根节点的深度，将浅的接入深的当中
		root[yroot]=xroot;
	else if(rooth[yroot]>rooth[xroot])
		root[xroot]=yroot;
	else//如果根节点深度相同，随意接入一个根节点，并把这个根节点深度加一
	{
		root[xroot]=yroot;
		rooth[yroot]++;
	}
	return 0;
}
int cmp(lujing a,lujing b)
{
	return a.l<b.l;
}
int mian()
{
	int n,m,sum=0;//n表示节点个数，m表示路径个数
	cin>>n>>m;
	memset(root,0,sizeof(root));
	memset(rooth,0,sizeof(rooth));//初始化节点数组跟根深数组 
	for(int i=0; i<m; i++)
		cin>>lj[i].x>>lj[i].y>>lj[i].l;//接收节点跟路径长度
	sort(lj,lj+m,cmp);//按照路径长度从小到大将结构体数组进行排序
	for(int i=0; i<m; i++)
	{
		int p=lian(lj[i].x,lj[i].y);//按照顺序将节点接入树中
		if(p==0)//如果这两个节点成功接入树中，将路径长度相加
			sum+=lj[i].l;
	}
	return 0;
}

最短路径迪杰斯特拉算法：

void dij(int begin)
{
	int i,j,k,l,min;
	int use[110],dis[110],par[110];
	//use用来存储节点是否访问过，dis用来存储最短路径，par用来存储父节点
	for(i=0; i<=n; i++)
	{
		use[i]=0;
		dis[i]=lj[1][i];
		par[i]=0;
	}//初始化
	use[1]=1;
	for(i=1; i<=n; i++)
	{
		k=0;
		min=MAX;
		for(j=1; j<=n; j++)//用来寻找最短的点
		{
			if(use[j]==0&&dis[j]<min)
			{
				min=dis[j];
				k=j;
			}
		}
		use[k]=1;
		for(l=1; l<=n; l++)//更新dis数组
		{
			if(use[l]==0&&(dis[l]>dis[k]+lj[k][l]))
			{
				dis[l]=dis[k]+lj[k][l];
				par[l]=k;
			}
		}
	}
	cout<<dis[n]<<endl;
}

__int128:

#include <bits/stdc++.h>
using namespace std;
inline __int128 read()//输出
{
	__int128 x=0,f=1;
	char ch=getchar();
	while(ch<'0'||ch>'9')
	{
		if(ch=='-')
			f=-1;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9')
	{
		x=x*10+ch-'0';
		ch=getchar();
	}
	return x*f;
}
inline void print(__int128 x)//接收
{
	if(x<0)
	{
		putchar('-');
		x=-x;
	}
	if(x>9)
		print(x/10);
	putchar(x%10+'0');
}
int main(void)
{
	__int128 a = read();
	__int128 b = read();
	print(a + b);
	cout<<endl;
	return 0;
}

快速幂：

int sp(int x,int n,int mod)//求x^n%mod
{
	ll res=1;
	while(n>0)
	{
		if(n&1)
		res=res*x%mod;
		x=x*x%mod;
		n>>=1;
	}
	return res;
}

GCD求最小公约数：

int gcd(int a,int b)
{
	return b==0?a:gcd(b,a%b);
}

素数筛：

int pd[100];//用来判断是否是素数 
void qiusu(int n)//求2到n之间的素数 
{
	memset(pd,0,sizeof(pd));//初始化 
	for(int i=2;i<=n;i++)
	{
		//如果循环到i，pd[i]=0，那么i就是素数；如果pd[i]=1，i就不是素数 
		if(pd[i]!=0) 
		continue;
		cout<<i<<endl;
		for(int j=i*2;j<=n;j+=i)//将i的倍数全部赋值为1，表示它们不是素数 
		pd[j]=1;
	}
 }