模板整理(持续更新)

目录

数论

数据结构

博弈论

递归实现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;i

vector

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...

你可能感兴趣的:(模板整理(持续更新))