模板整理（持续更新）
目录
数论
数据结构
博弈论
递归实现n！
图论（待补充）
数组/字符串类
DP类
1~n全排列（递归实现）
1~n全排列（利用STL）
DFS模板
判断1~1e9之内的数是不是素数
Warshall算法求传递闭包（O(n^3)）
数论
快速幂取模
int Pow(int a,int b,int c)
{
int res=1;
while(b>0)
{
if(b&1) res=res*a%c;
a=a*a%c;
b>>=1;
}
return res;
}//复杂度O(logn)二分乘法
用途：用来解决乘法的结果远超long long范围，但需要的结果有取余的乘法运算
时间复杂度：和快速幂一样，为O(logn)
ll qmul(ll a,ll b,ll m)
{
ll ans=0;
ll k=a;
ll f=1;//f是用来存负号的
if(k<0)
{f=-1;k=-k;}
if(b<0)
{f*=-1;b=-b;}
while(b){
if(b&1)
ans=(ans+k)%m;
k=(k+k)%m;
b>>=1;
}
return ans*f;
}快速乘
和二分乘法的用途一样，但是时间复杂度为O(1)
ll modmul(ll A,ll B,ll Mod)
{
return (A*B-(ll)((long double)A*B/Mod)*Mod+Mod)%Mod;
}gcd
int gcd(int a,int b)
{
return b==0?a:gcd(b,a%b);
}lcm
int lcm(int a,int b)
{
return a/gcd(a,b)*b;//如果先运算a*b，很可能超数据范围
}扩展欧几里得（递归）
int exgcd(int a,int b,int &x,int &y)
{
if(b==0)
{
x=1;
y=0;
return a;
}
int r=exgcd(b,a%b,x,y);
int t=x;
x=y;
y=t-a/b*y;
return r;
}欧拉函数
//欧拉函数公式：
//φ(N)=N*(1-1/P1)*(1-1/P2)*...*(1-1/Pn).
int Eular(int n)
{
int eu = n;
for (int i = 2 ; i * i <= n ; i++)
{
if (n % i == 0)
{
eu -= eu / i;
while (n % i == 0)
n /= i;
}
}
if (n > 1) //n本身也是个质因子
eu -= eu / n;
return eu;
}
欧拉函数打表
void Eular()
{
euler[1]=1;
for(int i=2;i容斥（二进制状态枚举）
int n;
for(int i=0;i<(1<>j)&1);
}
}
/**********应用*************/
// 二进制枚举计算[1,n]区间内有多少和数组a互质/不互质的数
ll ans = 0;
for(int i = 1; i < (1 << n); i++)
{ // 相当于枚举所有的情况 o(2^n*n)
int cnt = 0; ll tmp = 1;
for(int j = 0; j < n ;j++)
{ // a[j]
if(i >> j & 1)
{
cnt ++;
tmp = lcm(tmp, a[j]);
}
}
if(cnt & 1) ans += n / tmp;
else ans -= n / tmp;
} 中国剩余定理
//chu是除数，yu是余数
//注意只适用于除数两两互质
#define ll long long
ll extended_euclid(ll a, ll b, ll &x, ll &y)
{
ll d;
if(b == 0)
{
x = 1;
y = 0;
return a;
}
d = extended_euclid(b, a % b, y, x);
y -= a / b * x;
return d;
}
ll chinese_remainder(ll b[], ll w[], ll len)
{
ll i, d, x, y, m, n, ret;
ret = 0; n = 1;
for(i=0; i < len ;i++)
n *= w[i];
for(i=0; i < len ;i++)
{
m = n / w[i];
d = extended_euclid(w[i], m, x, y);
ret = (ret + y*m*b[i]) % n;
}
return (n + ret%n) % n;
}数据结构
归并排序
#include
using namespace std;
const int maxn=1e6+10;
int ans;//记录逆序对数
int a[maxn];//原数组
int b[maxn];//作用是记录排好序的数组
//将有二个有序数列a[first...mid]和a[mid...last]合并。
void mergearray(int a[], int first, int mid, int last, int temp[])
{
int i = first, j = mid + 1;
int m = mid, n = last;
int k = 0;
while (i <= m && j <= n)
{
if (a[i] <= a[j])
temp[k++] = a[i++];
else
{
temp[k++] = a[j++];
ans+=mid-i+1;//对逆序数进行记录
}
}
while (i <= m)
temp[k++] = a[i++];
while (j <= n)
temp[k++] = a[j++];
k=first;
i=0;
while(i>n;
for(int i=0;i>a[i];
ans=0;
//用这个求逆序对数速度超级快，不知道为什么
MergeSort(a, n);
//mergesort(a,0,n-1,b);
cout< 博弈论
威佐夫博奕
//有2堆石子。A B两个人轮流拿，A先拿。
//每次可以从一堆中取任意个或从2堆中取相同数量的石子，但不可不取。
//拿到最后1颗石子的人获胜。
void Witzov_game(int a,int b)//a代表第一堆，b代表第二堆
{
if(a>b) swap(a,b);//如果a>b交换a，b的值
int k=(double)a*(i-1.0)/2.0;
int x=k*(1+i)/2;
if(x==a&&a+k==b) printf("First one take win\n");
else
{
k++;
x=k*(i+1)/2;
if(x==a&&a+k==b) printf("Last one take win\n");
else printf("First one take win\n");
}
}Nim博弈
//有N堆石子。A B两个人轮流拿，A先拿。
//每次只能从一堆中取若干个，可将一堆全取走，
//但不可不取，拿到最后1颗石子的人获胜。
int a[N];//有N堆石子
void Nimbo()
{
int res=0;
for(int i=1;i<=N;i++)
{
res^=a[i];
}
if(res)
printf("Firse one take win\n");
else
printf("Last one take win\n");
}Bash博弈
//有一堆石子共有N个。A B两个人轮流拿，A先拿。
//每次最少拿1颗，最多拿K颗，
//拿到最后1颗石子的人获胜。
void Bash_game(int N,int K)
{
if (N%(K+1)==0)
{
std::cout<<"Last one take win"<递归实现n！
int fact(int n)
{
/*if(n==0||n==1) return 1;
else return n*fact(n-1);*/
return n==0?1:fact(n-1)*n;//上面注释的简化版
}图论（待补充）
建图方式
链式前向星
// 遍历以u为起始位置的所有边(逆序遍历)
// for(int i=head[u];~i;ivector
struct Edge
{
int y;
int value;
};
vectorV[maxn];
inline void add(int u,int v,int w)
{
V[u].push_back((Edge{v,w}));
}
inline void print(int u) //遍历以u为起始位置的所有的边
{
// 输出与u相连的边和对应的权值
for(int i=0;i "<拓扑排序
void toposort()
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(!vis[j])//如果入度为0（没有前驱点）
{
vis[j]--;//入度变成-1进行标记（入度为-1的点均为已经删除的点）
printf("%d",j);//输出该节点
if(i!=n)
printf(" ");
else
printf("\n");
for(int k=1;k<=n;k++)
{
if(p[j][k])
vis[k]--;//将与j相连的节点都删去（删除与j有关的边）
}
break;
}
}
}
}
最短路
Dijkstra（单源最短路）
邻接矩阵（时间复杂度O(n^2)）
#include
using namespace std;
#define INF 0x7f7f7f7f
const int maxn=1e3+10;
int edge[maxn][maxn];
int flag[maxn]; //flag[i]标记节点i是否被查询
int dis[maxn]; //dis[i]表示节点i距离起始节点的最短距离
int n,m; //n个点，m条边
void Dijkstra()
{
memset(flag,0,sizeof(flag));
int ans,x;
for(int i=1;i<=n;i++)
dis[i]=edge[1][i];
dis[1]=0;
flag[1]=1;
for(int i=1;i<=n;i++)
{
ans=INF;
for(int j=1;j<=n;j++)
{
if(ans>dis[j]&&!flag[j])
{
ans=dis[j];
x=j;
}
}
flag[x]=1;
for(int j=1;j<=n;j++)
if(!flag[j])
dis[j]=min(dis[j],dis[x]+edge[x][j]);
}
}
int main(int argc, char const *argv[])
{
cin>>n>>m;
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
edge[i][j]=INF;
memset(dis,INF,sizeof(dis));
int x,y,z;
while(m--)
{
cin>>x>>y>>z;
edge[x][y]=z;
edge[y][x]=z;
}
Dijkstra();
for(int i=1;i<=n;i++)
cout<<"节点 "<
链式前向星+堆优化 （时间复杂度O(E*log(V)）
#include
using namespace std;
#define INF 0x7f7f7f7f
const int maxn=1e3+10;
struct Edge
{
int Next; //下一条变的储存下标
int to; //这条边的终点
int value; //权值
}edge[maxn];
int cnt;
int n,m,s; //s表示起点
int head[maxn];
int dis[maxn]; //最短距离
// 堆节点
struct node
{
int u,d;
bool operator < (const node& dui) const {return d>dui.d;}
};
inline void add(int u,int v,int w)
{
edge[cnt].Next=head[u];
edge[cnt].value=w;
edge[cnt].to=v;
head[u]=cnt++;
}
inline void dijkstra(int a)
{
memset(dis,INF,sizeof(dis));
priority_queueq;
q.push(node{a,0});
dis[a]=0;
while(!q.empty())
{
node res=q.top();q.pop();
int u=res.u,d=res.d;
/////////////////////
// 注意：没有下面这个会超时！！！
/////////////////////
if(d!=dis[u])
continue;
for(int k=head[u];~k;k=edge[k].Next)
{
int v=edge[k].to,w=edge[k].value;
if(dis[v]>dis[u]+edge[k].value)
{
dis[v]=dis[u]+w;
q.push((node){v,dis[v]});
}
}
}
}
int main(int argc, char const *argv[])
{
memset(head,-1,sizeof(head));
scanf("%d%d%d",&n,&m,&s);
int x,y,z;
while(m--)
{
scanf("%d%d%d",&x,&y,&z);
add(x,y,z);
}
dijkstra(s);
for(int i=1;i<=n;i++)
{
printf("%d ",dis[i]);
}
printf("\n");
return 0;
}
Spfa（单源最短路）
链式前向星（时间复杂度O(K*E)）
//不想敲了，副会长的代码直接粘来算了(～￣▽￣)～
#include
#include
#include
using namespace std;
// <1> spfa求单源最短路,链式前向星存图 时间复杂度o(kE) k是常数，大多数情况下为2
const int N = (int) 1e5 + 11; // 最大点数
const int M = (int) 1e6 + 11; // 最大边数
const int INF = (int) 0x3f3f3f3f;
struct Edge{ // 边的定义
int to, val, next;
Edge(){}
Edge(int _to, int _val, int _next){
to = _to; val = _val; next = _next;
}
}edge[M << 1]; // !!如果是双向图的话，边的数量是题目中描述的二倍
int n, m; // n 是图中的点数，m是图中的边数
int head[N], top;
void init(int n){ // 初始化
memset(head, -1, sizeof(int) * (n + 1));
top = 0;
}
void Add(int u, int v, int val){ // 加单向边
edge[top] = Edge(v, val, head[u]);
head[u] = top++;
}
void getmap(int m){ // 建图
int u, v, val;
while(m--){
scanf("%d%d%d",&u , &v, &val); // u->v有边
Add(u, v, val);
Add(v, u, val); // 如果是双向图，加上这个代码
}
}
bool vis[N]; int dis[N];
void spfa(int st, int ed){ // 核心代码,点序号从0-(n-1)或者1-n都可以
memset(dis, 0x3f, sizeof(int) * (n + 1));
memset(vis, false, sizeof(bool) * (n + 1)); // 清空和初始化
queueque; que.push(st);
vis[st] = true; dis[st] = 0;
while(!que.empty()){
int u = que.front(); que.pop(); vis[u] = false;
for(int i = head[u]; ~i; i = edge[i].next){
Edge e = edge[i];
if(dis[e.to] > dis[u] + e.val) {//是否可以进行松弛
dis[e.to] = dis[u] + e.val;
if(!vis[e.to]){ // 是否在队列中，如果在可以跳过
que.push(e.to);
vis[e.to] = true;
}
}
}
}
printf("%d\n", dis[ed] == INF ? -1 : dis[ed]); // st到不了ed输出-1
}
int main(){
int t; scanf("%d%d", &t, &n);
init(n);
getmap(t);
spfa(n, 1);
return 0;
}
Floyd（多源最短路）
邻接矩阵（时间复杂度O(n^3)）
#include
#define INF 0x7f7f7f7f
const int maxn=1e3+10;
using namespace std;
int n,m;
int edge[maxn][maxn];
//初始化
inline void init(int n)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(i==j)
edge[i][j]=0;
else
edge[i][j]=edge[j][i]=INF;
}
}
}
// 建图
inline void add(int m)
{
int u,v,val;
while(m--)
{
cin>>u>>v>>val;
// 双向图写这行
edge[u][v]=edge[v][u]=min(edge[u][v],val);
// 单向图写这行
//edge[u][v] = min(edge[u][v], val);
}
}
inline void floyd(int n)
{
for(int k=1;k<=n;k++)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
edge[i][j]=min(edge[i][j],edge[i][k]+edge[k][j]);
}
}
}
}
int main(int argc, char const *argv[])
{
cin>>n>>m;
init(n);
add(m);
floyd(n);
cout<<(edge[n][1]==INF?-1:edge[n][1])<
第K短路
Spfa+A*
#include
#define ms(a) memset(a,0,sizeof(a))
#define INF 0x7f7f7f7f
#define ll long long
const int maxn=1e6+10;
using namespace std;
ll num1=0,num2=0;
ll n,m;//n个点m条边
ll s,t,k;//S->起点,t->终点,k->第k短路
ll h1[maxn],h2[maxn],d[maxn],flag[maxn];
struct node1
{
ll x,y,z,next;
}mp1[maxn],mp2[maxn];
struct node
{
ll v,c;
node(ll vv,ll cc) : v(vv),c(cc){}
friend bool operator < (node x,node y){return x.c+d[x.v]>y.c+d[y.v];}
};
inline void insert1(ll x,ll y,ll z)
{
mp1[++num1].x=x;
mp1[num1].y=y;
mp1[num1].z=z;
mp1[num1].next=h1[x];
h1[x]=num1;
}
inline void insert2(ll x,ll y,ll z)
{
mp2[++num2].x=x;
mp2[num2].y=y;
mp2[num2].z=z;
mp2[num2].next=h2[x];
h2[x]=num2;
}
void spfa()
{
queueQ;
Q.push(t);
for(int i=1;i<=n;i++)
d[i]=INF;
d[t]=0;
ms(flag);
flag[t]=1;
while(!Q.empty())
{
ll u=Q.front();
Q.pop();
flag[u]=0;
for(int i=h1[u];i;i=mp1[i].next)
{
ll v=mp1[i].y;
if(d[v]>d[u]+mp1[i].z)
{
d[v]=d[u]+mp1[i].z;
if(!flag[v])
{
flag[v]=1;
Q.push(v);
}
}
}
}
}
ll astar()
{
if(d[s]==INF)
return -1;
priority_queuep;
ll cnt=0;p.push(node(s,0));
while(!p.empty())
{
node u=p.top();p.pop();
if(u.v==t)
{
cnt++;
if(cnt==k) return u.c;
}
for(int i=h2[u.v];i;i=mp2[i].next)
{
ll y=mp2[i].y;
p.push(node(y,u.c+mp2[i].z));
}
}
return -1;
}
int main(int argc, char const *argv[])
{
while(cin>>n>>m)
{
ms(h1);num1=0;
ms(h2);num2=0;
while(m--)
{
ll x,y,z;//起点，终点，权值
cin>>x>>y>>z;
insert1(y,x,z);
insert2(x,y,z);
}
cin>>s>>t>>k;
// 看清题目要求吧，POJ2449那题s和t是同一点时不能直接到达，要再走一圈
// if(s==t)
// k+=1;
spfa();
cout<
并查集
init()
{
for(int i=0;i<=n;i++)
f[i]=i;
}
// 查询根节点（路径压缩）
int Find(int x)
{
if(f[x]==x)
return x;
return f[x]=Find(f[x]);
}
// 合并点
void Join(int x,int y)
{
f[Find(y)]=Find(x);
}
最小生成树
Kruskal
#include
#define ll long long
#define ull unsigned long long
#define ms(a,b) memset(a,b,sizeof(a))
const int inf=(1<<30);
const ll INF=(1LL*1<<60);
const int maxn=1e6+10;
const int mod=1e9+7;
const int maxm=1e3+10;
using namespace std;
struct edge
{
int u,v,w;
}Edge[maxn];
int tol;
int f[maxn];
void add(int u,int v,int w)
{
Edge[tol].u=u;
Edge[tol].v=v;
Edge[tol++].w=w;
}
bool cmp(edge u,edge v)
{
return u.w>n>>m;
for(int i=0;i<=n;i++)
f[i]=i;
int x,y,z;
tol=0;
for(int i=0;i>x>>y>>z;
add(x,y,z);
add(y,x,z);
}
sort(Edge,Edge+tol,cmp);
int ans=Kruskal(n);
if(ans==-1)
cout<<"orz"<
数组/字符串类
最长回文子串长度（Manacher算法）
//复杂度O(n)
void Manacher()
{
l=strlen(ch);
//处理字符串，在字符串开头，结尾都加上'#'
for(int i=l;i>0;i--)//注意是从最后一位开始处理
{
ch[2*i]=ch[i-1];
ch[2*i+1]='#';
}
ch[0]='$';//避免出现越界问题
ch[1]='#';
int id,mx,ans;//id最大回文子串中心的位置，mx最大回文子串的边界
id=mx=ans=0;
for(int i=1;i<=2*l+1;i++)
{
if(mx>i) vis[i]=min(vis[2*id-i],mx-i);
else vis[i]=1;
while(ch[i+vis[i]]==ch[i-vis[i]]) vis[i]++;
if(mx
KMP（Kuangbin's）
// 字符串是从0开始的
// Next数组是从1开始的
void getNext()
{
int j, k;
j = 0; k = -1; next[0] = -1;
while(j < tlen)
if(k == -1 || T[j] == T[k])
next[++j] = ++k;
else
k = next[k];
}
/*
返回模式串T在主串S中首次出现的位置
返回的位置是从0开始的。
*/
int KMP_Index()
{
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 - tlen;
else
return -1;
}
/*
返回模式串在主串S中出现的次数
*/
int KMP_Count()
{
int ans = 0;
int i, j = 0;
if(slen == 1 && tlen == 1)
{
if(S[0] == T[0])
return 1;
else
return 0;
}
getNext();
for(i = 0; i < slen; i++)
{
while(j > 0 && S[i] != T[j])
j = next[j];
if(S[i] == T[j])
j++;
if(j == tlen)
{
ans++;
j = next[j];
}
}
return ans;
}
前缀和
void Prefix(int n)
{
memset(sum,0,sizeof(sum));
for(int i=1;i<=n;i++)
sum[i]=sum[i-1]+a[i];
}
DP类
背包类
01背包（每种物品只有一个）
//n 物品数量，v 背包容量
//size 单个物品体积，value 单个物品价值
void bag01()
{
for(int i=0;i=size[i];j--)
{
dp[j]=max(dp[j],dp[j-size[i]]+value[i]);
}
cout<
完全背包（每种物品有无穷多）
void complete()
{
for(int i=0;i
多重背包（每种物品数量有限）
//n 物品数量，v 背包容量
//size 单个物品体积，value 单个物品价值，num 该物品的数量
void multiply()
{
for(int i=0;i=d1*size[i];j--)
{
dp[j]=max(dp[j],dp[j-d1*size[i]]+value[i]*d1);
}
d2-=d1;
d1*=2;
}
for(int j=v;j>=d2*size[i];j--) dp[j]=max(dp[j],dp[j-d2*size[i]]+value[i]*d2);
}
cout<
最长上升子序列（LIS）
//这个是计算连续的上升序列 如：1，2，3,4这种
void lis(int n)//n是数组元素的个数
{
for(int i=1;i<=n;i++)
{
b[a[i]]=b[a[i]-1]+1;
ans=std::max(ans,b[a[i]]);
}
}
//这个计算的是递增的（不需要连续递增）如：1,3,5,7这种
int a[maxn];
int dp[maxn];
int n;
void longest()
{
dp[0]=a[0];
int pos;
int L=1;
for(int i=0;i
最长公共子序列（LCS）
//状态转移方程：
// if( s[i]==t[j] )
// dp[i+1][j+1] = dp[i][j] + 1;
// else
// dp[i+1][j+1] = max(dp[i+1][j], dp[i][j+1]);
int dp[maxn][maxn];
char a[maxn],b[maxn];
int vis[maxn][maxn];//只求长度的时候可以去掉
// 如果要输出公共子序列，把int改成void，并把return去掉
int LCS()
{
int len1,len2,i,j;
len1=strlen(a);
len2=strlen(b);
memset(dp,0,sizeof(dp));
for(i=1;i<=len1;i++)
for(j=1;j<=len2;j++)
{
if(a[i-1]==b[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];
vis[i][j]=1;
}
else
{
dp[i][j]=dp[i][j-1];
vis[i][j]=-1;
}
}
return dp[len1][len2];
}
// 这个函数可以将LCS打印出来
void Print(int i, int j)//i，j分别代表a，b字符串的长度
{
if(i==0||j==0)
return;
if(!vis[i][j])//如果a[i]和b[j]子母相同，输出
{
Print(i-1,j-1);
printf("%c",a[i-1]);
}
else if(vis[i][j]==1)//如果dp[i-1][j]>dp[i][j-1]
Print(i-1,j);
else//如果dp[i][j-1]>=dp[i-1][j]
Print(i,j-1);
}
1~n全排列（递归实现）
int vis[10];//用于标记是否被访问过，0--未访问 1--已访问
int ans[10];//用于存储答案
int step,n;
void dfs(int step)
{
for(int i=1;i<=n;i++)
{
if(vis[i]==0)
{
vis[i]=1;
ans[step]=i;//将答案存储
if(step
1~n全排列（利用STL）
void Full(int n)
{
for(int i=0;i
DFS模板
void dfs()//参数用来表示状态
{
if(到达终点状态)
{
...//根据题意来添加
return;
}
if(越界或者是不符合法状态)
return;
for(扩展方式)
{
if(扩展方式所达到状态合法)
{
....//根据题意来添加
标记；
dfs（）；
修改（剪枝）；
(还原标记)；
//是否还原标记根据题意
//如果加上（还原标记）就是 回溯法
}
}
}
判断1~1e9之内的数是不是素数
//是素数prime(n)==true
bool prime(int n)
{
for(int i=2;i*i<=n;i++)
if(n%i==0)
return false;
return n!=1;
}
vector divisor(int n)
{
vector res;
for(int i=1;i*i<=n;i++)
{
if(n%i==0)
{
res.push_back(i);
if(i!=n/i) res.push_back(n/i);
}
}
return res;
}
map factor(int n)
{
map res;
for(int i=2;i*i<=n;i++)
{
while(n%i==0)
{
++res[i];
n/=i;
}
if(n!=1) res[n]=1;
return res;
}
}
Warshall算法求传递闭包（O(n^3)）
void Warshall()
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(a[j][i])
{
for(int k=0;k<=n;k++)
{
a[j][k]=a[j][k]|a[i][k];
}
}
}
}
}
To be continued...