标签：质因数分解 div 开始 bool 剩余定理 else 时间复杂度 标记 求逆
沙雕的gcd:
//1.gcd int gcd(int a,int b) { return b?gcd(b,a%b):a; }
还有个exgcd：
//2.扩展gcd )extend great common divisor ll exgcd(ll l,ll r,ll &x,ll &y) { if(r==0) { x=1; y=0; return l; } else { ll d=exgcd(r,l%r,y,x); y-=l/r*x; return d; } }
求逆元：
//3.求a关于m的乘法逆元 ll mod_inverse(ll a,ll m) { ll x,y; if(exgcd(a,m,x,y)==1)//ax+my=1 return (x%m+m)%m; return -1;//不存在 }
快速幂：
//4.快速幂quick power ll qpow(ll a,ll b,ll m) { ll ans=1; ll k=a; while(b) { if(b&1)ans=ans*k%m; k=k*k%m; b>>=1; } return ans; }
快速乘（也叫二分乘法）:
//5.快速乘,直接乘会爆ll时需要它，也叫二分乘法。 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; }
中国剩余定理：
//6.中国剩余定理CRT (x=ai mod mi) ll china(ll n, ll *a,ll *m) { ll M=1,y,x=0,d; for(ll i = 1; i <= n; i++) M *= m[i]; for(ll i = 1; i <= n; i++) { ll w = M /m[i]; exgcd(m[i], w, d, y);//m[i]*d+w*y=1 x = (x + y*w*a[i]) % M; } return (x+M)%M; }
筛素数：
//7.筛素数，全局：int cnt,prime[N],p[N]; void isprime() { cnt = 0; memset(prime,true,sizeof(prime)); for(int i=2; i<N; i++) { if(prime[i]) { p[cnt++] = i; for(int j=i+i; j<N; j+=i) prime[j] = false; } } }
快速计算逆元：
//8.快速计算逆元 //补充：>>关于快速算逆元的递推式的证明<< void inverse() { inv[1] = 1; for(int i=2; i<N; i++) { if(i >= M) break; inv[i] = (M-M/i)*inv[M%i]%M; } }
组合数取模：
//9.组合数取模 n和m 10^5时，预处理出逆元和阶乘 ll fac[N]= {1,1},inv[N]= {1,1},f[N]= {1,1}; ll C(ll a,ll b) { if(b>a)return 0; return fac[a]*inv[b]%M*inv[a-b]%M; } void init() { //快速计算阶乘的逆元 for(int i=2; i<N; i++) { fac[i]=fac[i-1]*i%M; f[i]=(M-M/i)*f[M%i]%M; inv[i]=inv[i-1]*f[i]%M; } } n较大10^9，但是m较小10^5时， ll C(ll n,ll m) { if(m>n)return 0; ll ans=1; for(int i=1; i<=m; i++) ans=ans*(n-i+1)%M*qpow(i,M-2,M)%M; return ans; } //n和m特别大10^18时但是p较小10^5时用lucas
Lucas大组合取模：
//10.Lucas大组合取模 #define N 100005 #define M 100007 ll n,m,fac[N]= {1}; ll C(ll n,ll m) { if(m>n)return 0; return fac[n]*qpow(fac[m],M-2,M)%M*qpow(fac[n-m],M-2,M)%M;//费马小定理求逆元 } ll lucas(ll n,ll m) { if(!m)return 1; return(C(n%M,m%M)*lucas(n/M,m/M))%M; } void init() { for(int i=1; i<=M; i++) fac[i]=fac[i-1]*i%M; }
质因数分解:
//11.质因数分解 cin>>n; for(int i=2; i<=n; i++) { if(n==0)break; while(n%i==0) { n/=i; k[++ans]=i; } }
试除法：
//12.试除法 bool check(int n) { if(n==1)return false; for(int i=2; i<=sqrt(n); ++i) if(n%i==0)return false; return true; }
miller-rabin算法：
//13.miller-rabin算法 int test[10]= {2,3,5,7,11,13,19,23}; int qpow(int a,int b,int p) { int ans=1; while(b) { if(b&1)ans=1ll*ans*a%p; a=1ll*a*a%p,b>>=1; } return ans; } bool miller_rabin(int p) { if(p==1)return 0; int t=p-1; k=0; while(!(t&1))k++,t>>=1; for(int i=0; i<8; ++i) { if(p==test[i])return 1; long long a=qpow(test[i],t,p,),nx=a; for(int j=1; j<=k; ++j) { nx=(a*a)%p; if(nx==1&&a!=1&&a!=p-1) return 0; a-nx; } if(a!=1)return 0; } return 1; }
快读：
//14.快读 inline int read() { int s=0,w=1; char ch=getchar(); while(ch<‘0‘||ch>‘9‘) { if(ch==‘-‘)w=-1; ch=getchar(); } while(ch>=‘0‘&&ch<=‘9‘) x=(x<<3)+(x<<1)+(ch^48),ch=getchar(); return s*w; }
spfa_dfs：
//15.spfa_dfs int spfa_dfs(int u) { vis[u]=1; for(int k=f[u]; k!=0; k=e[k].next) { int v=e[k].v,w=e[k].w; if( d[u]+w < d[v] ) { d[v]=d[u]+w; if(!vis[v]) { if(spfa_dfs(v)) return 1; } else return 1; } } vis[u]=0; return 0; }
spfa_dfs:
//16、spfa_bfs int spfa_bfs(int s) { queue <int> q; memset(d,0x3f,sizeof(d)); d[s]=0; memset(c,0,sizeof(c)); memset(vis,0,sizeof(vis)); q.push(s); vis[s]=1; c[s]=1; //顶点入队vis要做标记，另外要统计顶点的入队次数 int OK=1; while(!q.empty()) { int x; x=q.front(); q.pop(); vis[x]=0; //队头元素出队，并且消除标记 for(int k=f[x]; k!=0; k=nnext[k]) { //遍历顶点x的邻接表 int y=v[k]; if( d[x]+w[k] < d[y]) { d[y]=d[x]+w[k]; //松弛 if(!vis[y]) { //顶点y不在队内 vis[y]=1; //标记 c[y]++; //统计次数 q.push(y); //入队 if(c[y]>NN) //超过入队次数上限，说明有负环 return OK=0; } } } } return OK; }
杂：
//cin,优化 cin.tie(0); ios_base::sync_with_stdio(false); //输出优化： void print( int k ) { num = 0; while( k > 0 ) ch[++num] = k % 10, k /= 10; while( num ) putchar( ch[num--]+48 ); putchar( 32 ); }
RMQ：
//区间查询最值问题 //预处理 void rmq_init() { for(int i=1; i<=N; i++) dp[i][0]=arr[i];//初始化 for(int j=1; (1<<j)<=N; j++) for(int i=1; i+(1<<j)-1<=N; i++) dp[i][j]=min(dp[i][j-1],dp[i+(1<<j-1)][j-1]); } //查询 int rmq(int l,int r) { int k=log2(r-l+1); return min(dp[l][k],dp[r-(1<<k)+1][k]); }
RMQ转LCA：
int euler[MAXN*2]; int dep[MAXN*2]; int pos[MAXN]; int top; int rmq[MAXN*2][16]; void dfs(int u,int depth,int fa) { euler[++top]=u; dep[top]=depth; pos[u]=top; INE(i,u,e) { int v=e[i].v; if(v==fa) continue; dfs(v,depth+1,u); euler[++top]=u; dep[top]=depth; } } void RMQinit() { rep(i,1,top) rmq[i][0]=i; rep(j,1,16) rep(i,1,top) if(i+(1<<j)-1<=top) { if(dep[rmq[i][j-1]]<dep[rmq[i+(1<<j-1)][j-1]]) rmq[i][j]=rmq[i][j-1]; else rmq[i][j]=rmq[i+(1<<j-1)][j-1]; } } int RMQ(int l,int r) { int len=r-l+1; int LOG=0; for(;1<<LOG+1<=len;LOG++); if(dep[rmq[l][LOG]]<dep[rmq[r-(1<<LOG)+1][LOG]]) return rmq[l][LOG]; else return rmq[r-(1<<LOG)+1][LOG]; } void LCAinit() { dfs(1,0,-1); RMQinit(); } int LCA(int u,int v) { if(pos[u]>pos[v]) swap(u,v); return euler[RMQ(pos[u],pos[v])]; }
tarjan求LCA:
//并查集记录父亲的数组. int father[MAXN]; //并查集的查找函数,有路径压缩功能. int find ( int x ) { return father[x] == x ? x : father[x] = find ( father[x]); } //采用邻接表存储 struct { int v,next,lca,u; } e[2][MAXN<<2]; //分别记录边对和查询数对 int head[2][MAXN]; int cc; //添加边,flag表示模式 void add ( int flag , int u , int v ) { e[flag][cc].u = u; e[flag][cc].v = v; e[flag][cc].next = head[flag][u]; head[flag][u] = cc++; } //标记当前点是否访问过 bool visited[MAXN]; void LCA ( int u ) { father[u] = u; visited[u] = true; //深度优先搜索整棵树 for ( int i = head[0][u]; i != -1 ; i = e[0][i].next ) { int v = e[0][i].v; if ( visited[v] ) continue; LCA ( v ); //从叶节点开始,逐层标记父节点 father[v] = u; } //当前子树已经维护,利用并查集找到当前子树的查询数对的LCA for ( int i = head[1][u]; i != -1 ; i = e[1][i].next ) { int v = e[1][i].v; if ( !visited[v] ) continue; //如果当前u,v都已经访问过,那么一定维护过的子树中 e[1][i].lca = e[1][i^1].lca = find ( v ); } }
倍增求LCA：
#include<bits/stdc++.h> using namespace std; struct node { int t,nex; } e[500001<<1]; int depht[500001],father[500001][22],lg[500001],head[500001]; int tot; inline void add(int x,int y) { e[++tot].t=y; e[tot].nex=head[x]; head[x]=tot; } inline void dfs(int now,int fath) { depht[now]=depht[fath]+1; father[now][0]=fath; for(register int i=1; (1<<i)<=depht[now]; ++i) father[now][i]=father[father[now][i-1]][i-1]; for(register int i=head[now]; i; i=e[i].nex) { if(e[i].t!=fath)dfs(e[i].t,now); } } inline int lca(int x,int y) { if(depht[x]<depht[y]) swap(x,y); while(depht[x]>depht[y]) x=father[x][lg[depht[x]-depht[y]]-1]; if(x==y) return x; for(register int k=lg[depht[x]]; k>=0; --k) if(father[x][k]!=father[y][k]) x=father[x][k],y=father[y][k]; return father[x][0]; } int n,m,s; int main() { scanf("%d%d%d",&n,&m,&s); for(register int i=1; i<=n-1; ++i) { int x,y; scanf("%d%d",&x,&y); add(x,y); add(y,x); } dfs(s,0); for(register int i=1; i<=n; ++i) lg[i]=lg[i-1]+(1<<lg[i-1]==i); for(register int i=1; i<=m; ++i) { int x,y; scanf("%d%d",&x,&y); printf("%d\n",lca(x,y)); } return 0; }
基环树找环：
#include <bits/stdc++.h> using namespace std; #define INF 0x3f3f3f3f #define MAXN 1000010 #define MAXM 5010 inline int read() { int x = 0,ff = 1;char ch = getchar(); while(!isdigit(ch)) { if(ch == ‘-‘) ff = -1; ch = getchar(); } while(isdigit(ch)) { x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar(); } return x * ff; } inline void write(int x) { if(x < 0) putchar(‘-‘),x = -x; if(x > 9) write(x / 10); putchar(x % 10 + ‘0‘); } int a,ti = 0,cnt = 0,fa[MAXN],vis[MAXN],loop[MAXN]; int lin[MAXN],tot = 0; struct edge { int y,v,next; }e[MAXN]; inline void add(int xx,int yy,int vv) { e[++tot].y = yy; e[tot].v = vv; e[tot].next = lin[xx]; lin[xx] = tot; } void get_loop(int x) { vis[x] = ++ti; for(int i = lin[x],y;i;i = e[i].next) { if((y = e[i].y) == fa[x]) continue; if(vis[y]) { if(vis[y] < vis[x]) continue; loop[++cnt] = y; for(y = fa[y];y != fa[x];y = fa[y]) loop[++cnt] = y; } else fa[y] = x,get_loop(y); } } int main() { a = read(); for(int i = 1;i <= a;++i) { int y,v; y = read(); v = read(); add(i,y,v); add(y,i,v); } get_loop(1); for(int i = 1;i <= cnt;++i) write(loop[i]),putchar(‘ ‘); return 0; }
有关最短路的东西：
//一、多源最短路算法——Floyd 算法 //floyd 算法主要用于求任意两点间的最短路径，也称最短最短路径问题 //核心代码： void floyd() { int i, j, k; for (k = 1; k <= n; ++k) //遍历所有的中间点 for (i = 1; i <= n; ++i) //遍历所有的起点 for (j = 1; j <= n; ++j) //遍历所有的终点 if (e[i][j] > e[i][k] + e[k][j]) //如果当前i-->j的距离大于i-->k--->j的距离之和 e[i][j] = e[i][k] + e[k][j];//更新从i--->j的最短路径 } // 时间复杂度:O(N^3） // 不能使用的情况：边中含有负权值 //二、单源最短路径算法——dijkstra //1、思想描述：当Q(一开始为所有节点的集合)非空时， //不断地将Q中的最小值u取出,然后放到S（最短路径的节点的集合）集合中， //然后遍历所有与u邻接的边，如果可以进行松弛， //则对便进行相应的松弛。。。 //2、实现 /** * 返回从v---->到target的最短路径 */ int dijkstra(int v) { int i; for(i = 1 ; i <= n ; ++i) { //初始化 s[i] = 0;//一开始，所有的点均为被访问过 dis[i] = map[v][i]; } dis[v] = 0; s[v] = true; for(i = 1 ; i < n ; ++i) { int min = inf,pos,j; for(j = 1 ; j <= n ; ++j)//寻找目前的最短路径的最小点 if(!s[j] && dis[j] < min) { min = dis[j]; pos = j; } s[pos] = 1; for(j = 1 ; j <= n ; j++)//遍历u的所有的邻接的边 if(!s[j] && dis[j] > dis[pos] + map[pos][j]) dis[j] = dis[pos] + map[pos][j];//对边进行松弛 } return dis[target]; } //3.基本结构 int s[maxn];//用来记录某一点是否被访问过 int map[maxn][maxn];//地图 int dis[maxn];//从原点到某一个点的最短距离(一开始是估算距离) //4.条件：使用dijkstra解决的题目一般有以下的特征： //给出点的数目、边的数目、起点和终点、边的信息(,并且边不包含负边权的值).求从起点到终点的最短路径的距离 //起点：用于dijkstra(int v)中的v //终点：用于return dis[target]中的target //边的信息：用于初始化map[][] //三：使用 bellmen-ford 算法 //算法介绍: //思想：其实bellman-ford的思想和dijkstra的是很像的， //其关键点都在于不断地对边进行松弛。 //而最大的区别就在于前者能作用于负边权的情况。 //其实现思路还是在求出最短路径后， //判断此刻是否还能对便进行松弛， //如果还能进行松弛，便说明还有负边权的边 //实现： bool bellmen_ford() { for(int i=1; i<=n; i++) dis[i]=inf; dis[source]=0; for(int i=1; i<n; i++) { for(int j=1; j<=m; j++) { dis[edge[j].v] = min(dis[edge[j].v],dis[edge[j].u] + edge[j].weight); dis[edge[j].u] =min(dis[edge[j].u],dis[edge[j].v] + edge[j].weight) ; } } for(j = 1 ; j <= m ; ++j) //判断是否有负边权的边 if(dis[edge[j].v] > dis[edge[j].u] + edge[j].weight) return false; return true; } //基本结构： struct Edge{ int u,v,weight; }edge[maxn]; int dis[maxn]; //条件：其实求最短路径的题目的基本条件都是点数，边数，起点终点 //四、使用spfa算法来解决 //思想：用于求单源最短路经，可以适用于负边权的情况（不过他已经死了
标签：质因数分解 div 开始 bool 剩余定理 else 时间复杂度 标记 求逆
原文地址：https://www.cnblogs.com/ydclyq/p/11663597.html
