【算法】模板汇总

2021 csp rp++

数学

欧几里得算法 gcd

int gcd(int a,int b){
	if(a<b) swap(a,b);
	if(!b) return a;
	else return gcd(b,a%b);
}

扩展欧几里得 Exgcd

ll a, b ,x ,y;
void exgcd(ll a,ll b){
	if(!b){x=1,y=0; return ;}
	exgcd(b,a%b);
	ll tx=x;
	x=y;
	y=tx-a/b*y;
}
int main(){
	cin>>a>>b;
	exgcd(a,b);
	x=(x+b)%b;
	cout<<x<<endl;
}

快速幂

ll b,p,k,s;

ll fpow(ll b,ll p){
	ll ans=1, base=b;
	while(p>0){
		if(p&1) ans=ans*base%k;
		base=base*base%k;
		p>>=1;
	}
	return ans%k;
}

int main(){
	cin>>b>>p>>k;
	s=fpow(b,p);
	printf("%lld^%lld mod %lld=%lld",b,p,k,s);
	return 0;
}

乘法逆元

//1~n在p下的乘法逆元 线性递推做法 

const int N=5000010;
ll n,p,inv[N];

int main(){
	cin>>n>>p;
	printf("1\n");
	inv[1]=1;
	for(int i=2;i<=n;i++){
		inv[i]=p-(p/i)*inv[p%i]%p;
		printf("%lld\n",inv[i]);
	}
	return 0;
}

//费马小定理
ll n,p;

ll fpow(ll b,ll tmp){
	ll ans=1,  base=b;
	while(tmp>0){
		if(tmp&1) ans=ans*base%p;
		base=base*base%p;
		tmp>>=1;
	}
	return ans;
}

int main(){
	cin>>n>>p;	
	for(int i=1;i<=n;i++){
		printf("%lld\n", fpow(i,p-2));
	}
}

//exgcd
ll n,p;
ll x,y,a,b;

void exgcd(ll a,ll b){
	if(b==0) {x=1,y=0; return ;}
	exgcd(b,a%b);
	ll tx=x;
	x=y;
	y=tx-a/b*y;
}
int main(){
	cin>>n>>p;
	exgcd(a,p);
	for(int i=1;i<=n;i++){
		exgcd(i,p);
		x=(x+p)%p;
		cout<<x<<endl;
	}
}

有理数取余

#include<iostream>
#include<cstdio>
using namespace std;
typedef long long ll;
const int mod=19260817;
ll a,b;

ll read(){
	ll x=0,f=1; char ch=getchar();
	if(ch=='-') f=-1, ch=getchar();
	while(ch<'0'||ch>'9') ch=getchar();
	while(ch>='0'&&ch<='9') x=((x<<1)+(x<<3))%mod+(ch^48), ch=getchar();
	return (x%mod)*f;
}

void exgcd(ll a,ll b,ll &x, ll &y){ //求逆元 
	if(!b) {x=1,y=0; return ;}
	exgcd(b,a%b,x,y);
	ll tx=x;
	x=y;
	y=tx-a/b*y;
}

int main(){
	ll x,y;
	a=read(); b=read();
	exgcd(b,mod,x,y);
	x=(x%mod+mod)%mod;
	printf("%lld",x%mod*a%mod);
	
}

中国剩余定理 Crt

ll n,m,M=1;
ll a[N],b[N];

void exgcd(ll a,ll b,ll &x, ll &y){
	if(!b){
		x=1,y=0; return ;
	}
	exgcd(b,a%b,x,y);
	ll tx=x;
	x=y;
	y=tx-(a/b)*y;
}

ll Intchina(){
	ll ans=0;
	for(int i=1;i<=n;i++){
		m=M/a[i]; ll x,y;
		exgcd(m,a[i],x,y);
		x=(x%a[i]+a[i])%a[i];
		ans=((ans+m*x*b[i])%M+M)%M;
	}
	return ans;
}

int main(){
	scanf("%lld",&n);
	for(int i=1;i<=n;i++){
		scanf("%lld%lld",&a[i],&b[i]);
		M*=a[i];
	}
	printf("%lld",Intchina());
}

线性筛

void sieve(){
	is[1]=1;
	for(int i=2;i<=n;i++){
		if(is[i]==0) pr[++cnt]=i;
		for(int j=1;j<=cnt&&i*pr[j]<=n;j++){
			is[i*pr[j]]=1;
			if(i%pr[j]==0) break;
		}
	}
}

组合数

#include<iostream>
#include<cstdio>
#include<string>
#define mod 1000000007
using namespace std;
const int Maxn=1e7;
int n,m;
int f[Maxn];

int cal(int n,int m){
	for(int i=1;i<=n;i++){
		f[0]=1;
		for(int j=i;j>=1;j--){
			f[j]=f[j-1]+f[j];
			f[j]%=mod;
			//printf("%d ",f[j]);
		}//printf("\n");
	}	
	return f[m];
} 

int main(){
	scanf("%d%d",&n,&m);
	printf("%d",cal(n,m));
	return 0;
}

康托展开

void ini(){
	f[0]=1;
	for(int i=1;i<=n;i++) 
		f[i]=(f[i-1]*i)%mod;
}

int cantor(int num[]){
	int ans=1; 
	for(int i=1;i<n;i++){
		int tmp=0;
		for(int j=i+1;j<=n;j++)
			if(num[j]<num[i])
				tmp++;
		ans=(ans+tmp*f[n-i]%mod)%mod;			
	}
	return ans%mod;
}

int main(){
	scanf("%d",&n);
	ini();
	for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	printf("%d",cantor(a));
}

树状数组优化

ll n,v[1001000],f[1001000];
//注意这里v存的是状态而不是具体数字 

ll lowbit(ll x){ return x&(-x);}
ll update(ll x ,ll k){
	for(ll i=x;i<=n;i+=lowbit(i)) 	v[i]+=k;
}
ll getsum(ll x){
	ll ans=0;
	for(ll i=x;i;i-=lowbit(i)) ans+=v[i]%mod;
	return ans%mod;
}
void ini(){
	f[0]=1;
	for(ll i=1;i<=n;i++)	f[i]=(f[i-1]*i)%mod, f[i]%=mod;
	for(int i=1;i<=n;i++)	update(i,1);
}

ll cantor(){
	ll ans=1;
	for(int i=1;i<=n;i++){
		ll x;	scanf("%lld",&x);
		ans=(ans+getsum(x-1)*f[n-i]%mod)%mod;
		update(x,-1); 
	}
	return ans%mod;
}

int main(){
	scanf("%lld",&n);
	ini();
	printf("%lld",cantor());	
}

字符串

kmp

const int N=1000100;
int ne[N];
char s[N],p[N];
int n,m;
int main(){
	cin>>s+1>>p+1;
	n=strlen(p+1);
	m=strlen(s+1);
	for(int i=2,j=0;i<=n;i++){
		while(j&&p[i]!=p[j+1]) j=ne[j];
		if(p[i]==p[j+1]) j++;
		ne[i]=j;
	}
	for(int i=1,j=0;i<=m;i++){
		while(j&&s[i]!=p[j+1]) j=ne[j];
		if(s[i]==p[j+1]) j++;
		if(j==n){
			printf("%d\n",i-n+1);
			j=ne[j];
		}
	}
	for(int i=1;i<=n;i++){
		printf("%d ",ne[i]);
	}
	return 0;
}

Trie

#include<iostream>
#include<cstdio>
using namespace std;

const int N=100010;
int n;
int son[N][26], cnt[N], idx;
char str[N];

void insert(char *str){
	int p=0;
	for(int i=0;str[i];i++){
		int u=str[i]-'a';
		if(!son[p][u]) son[p][u]=++idx;
		p=son[p][u];
	}
	cnt[p]++;
}

int query(char *str){
	int p=0;
	for(int i=0;str[i];i++){
		int u=str[i]-'a';
		if(!son[p][u]) return 0;
		p=son[p][u];
	}
	return cnt[p];
}

int main(){
	cin>>n;
	while(n--){
		char op[2];
		scanf("%s%s",op,str);
		if(op[0]=='I') insert(str);
		else printf("%d\n",query(str));
	}
	return 0;
}

数据结构

并查集

int find(int k){
	if(fa[k]==k) return k;
	else return fa[k]=find(fa[k]);
}

并查集压缩路径

int find(int x){
    if(f[x]!=x){
        int root=find(f[x]);
        d[x]+=d[f[x]];
        f[x]=root;
    }
    return f[x];
}

ST表

const int N=100100;
int n,m,len;
int f[N][40];
int read(){
	int x=0,f=1; char ch=getchar();
	if(ch=='-') f=-1, ch=getchar();
	while(ch<'0'||ch>'9') ch=getchar();
	while(ch>='0'&&ch<='9') x=(x<<1)+(x<<3)+(ch^48), ch=getchar();
	return x*f;
}
int main(){
	n=read(); m=read();
	for(int i=1;i<=n;i++){
		f[i][0]=read();
	}	
	len=(int)(log(n)/log(2));
	for(int j=1;j<=len;j++){
		for(int i=1;i+(1<<j)-1<=n;i++){
			f[i][j]=max(f[i][j-1],f[i+(1<<(j-1))][j-1]);
		}
	}
	
	for(int i=1;i<=m;i++){
		int r,l; l=read(); r=read();
		int p=(int)(log(r-l+1)/log(2));
		cout<<max(f[l][p],f[r-(1<<p)+1][p])<<endl;
	}
}

树状数组

#include<iostream>
#include<cstdio>
using namespace std;

const int N=610000;
int n,m,a[N];

int lowbit(int x){
	return x&(-x);
}

int update(int x,int k){
	for(int i=x;i<=n;i+=lowbit(i))	a[i]+=k;	
}

int getsum(int x){
	int ans=0;
	for(int i=x;i;i-=lowbit(i)) ans+=a[i];
	return ans;
}

int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++) {
		int x;	cin>>x; 
		update(i,x);
	}
	for(int i=1;i<=m;i++){
		int t,x,y; 	cin>>t>>x>>y;
		if(t==1) 
			update(x,y);
		else 
			cout<<getsum(y)-getsum(x-1)<<endl;
	}
}

图论

dj

#include<iostream>
#include<cstdio>
#include<queue>
#define maxn 120000
#define inf 0x3f3f3f3f
using namespace std;
int n,m,s,ct;
int dis[maxn],vis[maxn],head[maxn];
struct edge{
	int to,next,w;
}e[maxn<<2];
struct node{
	int now,dis;
	bool operator<(const node &x)const{
		return x.dis<dis;
	}
};
priority_queue<node>q;
void add(int u,int v,int w){
	ct++; e[ct].to =v;
	e[ct].next =head[u];
	e[ct].w=w;
	head[u]=ct;
}
void dj(int s){
	for(int i=1;i<=n;i++) dis[i]=inf;
	q.push((node){s,0}); dis[s]=0;
	while(!q.empty() ){
		int t=q.top().now; q.pop() ;
		if(!vis[t]){
			vis[t]=1;
			for(int i=head[t];i;i=e[i].next ){
				int v=e[i].to ;
				if(dis[v]>dis[t]+e[i].w){
					dis[v]=dis[t]+e[i].w;
					q.push((node){v,dis[v]});  //不用判vis
				}
			}
		}
	} 
}
int main(){
	scanf("%d%d%d",&n,&m,&s);
	for(int i=1;i<=m;i++){
		int u,v,w;
		scanf("%d%d%d",&u,&v,&w);
		add(u,v,w);
	}
	dj(s);
	for(int i=1;i<=n;i++) printf("%d ",dis[i]);
}

Tarjan缩点

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<stack>
#define maxn 10200
using namespace std;

int n,m,a[maxn],c;
int dfn[maxn],low[maxn],vis[maxn],be[maxn];
int w[maxn],in[maxn],dis[maxn],ans;
vector<int>e[maxn];
vector<int>p[maxn];
queue<int>q;
stack<int>s;

void tarjan(int u){
	dfn[u]=low[u]=++c;
	s.push(u); vis[u]=1;
	for(int i=0;i<e[u].size();i++){
		int v=e[u][i];
		if(!dfn[v]){
			tarjan(v);
			low[u]=min(low[u],low[v]);
		}
		else if(vis[v]){
			low[u]=min(low[u],dfn[v]);
		}
	}
	if(dfn[u]==low[u]){
		int top;
		do{
			top=s.top(); s.pop();
			be[top]=u;
			vis[top]=0;
		}while(top!=u);
	}
}
void build(){
	for(int u=1;u<=n;u++){
		if(!dfn[u]) continue;
		for(int i=0;i<e[u].size();i++){
			int v=e[u][i];
			if(be[u]==be[v]) continue;
			p[be[u]].push_back(be[v]);
			in[be[v]]++;
		}
		w[be[u]]+=a[u];
	}
}
void topo(){
	for(int i=1;i<=n;i++)
		if(i==be[i]&&in[i]==0) q.push (i), dis[i]=w[i];
	while(!q.empty()){
		int u=q.front() ; q.pop() ;
		for(int i=0;i<p[u].size();i++){
			int v=p[u][i];
			dis[v]=max(dis[v],dis[u]+w[v]);
			in[v]--;
			if(!in[v]) q.push(v); 	
		}	
	}
}
int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++)	cin>>a[i];
	for(int i=1;i<=m;i++){
		int u,v; cin>>u>>v;
		e[u].push_back(v);
	}
	for(int i=1;i<=n;i++) 
		if(!dfn[i]) tarjan(i);
	
	build(); //重建图
	topo(); //拓扑跑最大点权
	for(int i=1;i<=n;i++){
		ans=max(ans,dis[i]);
	}
	printf("%d",ans);
}

Tarjan 求割边dfn[u]<low[v]

炸铁路P1656

int n,m,c;
int head[maxn];
int dfn[maxn],low[maxn],be[maxn],vis[maxn];
int br[maxm],cnt,act;

stack<int>s;
struct edge{
	int x,y;
}ans[maxm];
struct node{
	int to,next,from;
}e[maxm];

void add(int u,int v){
	cnt++;
	e[cnt].to =v;
	e[cnt].from=u;
	e[cnt].next =head[u];
	head[u]=cnt;
}
void add_br(int u,int v){
	if(u>v) return;
	act++;
	ans[act].x=u;
	ans[act].y=v;
}

bool cmp(edge a, edge b){
	if(a.x==b.x) return a.y<b.y;
	else return a.x<b.x;
}

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

void tarjan(int u,int f){ //注意求割边要关注的是fa节点
	dfn[u]=low[u]=++c;
	for(int i=head[u];i;i=e[i].next ){
		int v=e[i].to ;
		if(!dfn[v]){
			tarjan(v,u);
			low[u]=min(low[u],low[v]);
			if(dfn[u]<low[v]){ //求割边
				add_br(u,v);
				add_br(v,u);
			}
		}
		else if(v!=f){ //特判一下不是fa节点才更新
			low[u]=min(low[u],dfn[v]);
		}
	} 
}

int main(){
	n=read(); m=read();
	for(int i=1;i<=m;i++){
		int a=read(), b=read();
		add(a,b);
		add(b,a);
	}
	for(int i=1;i<=n;i++)
		if(!dfn[i]) tarjan(i,-1);
	sort(ans+1,ans+1+act,cmp);
	for(int i=1;i<=act;i++){
		printf("%d %d\n",ans[i].x,ans[i].y);
	}
}

Tarjan 求割点dfn[u]<=low[v]

int n,m,c,cnt;
int dfn[maxn],low[maxn],vis[maxn],cut[maxn],root;
vector<int>e[maxn<<1];

void add(int u,int v){
	e[u].push_back(v);
	e[v].push_back(u);
}

void tarjan(int u){
	int flag=0;
	dfn[u]=low[u]=++c;
	for(int i=0;i<e[u].size();i++){
		int v=e[u][i] ;
		if(!dfn[v]){
			tarjan(v);
			low[u]=min(low[u],low[v]);
			if(dfn[u]<=low[v]){
				flag++;
				if(flag>1||u!=root){
					cut[u]=1;
				}
			}
		}
		else low[u]=min(low[u],dfn[v]);
	}
}

int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++){
		int u,v;
		scanf("%d%d",&u,&v);
		add(u,v);
	}
	for(int i=1;i<=n;i++)
		if(!dfn[i]) root=i,tarjan(i);
		
	for(int i=1;i<=n;i++)
		if(cut[i]) cnt++;
	printf("%d\n",cnt);
	for(int i=1;i<=n;i++)
		if(cut[i]) printf("%d ",i);
}

差分约束&&判负环

判负环：一个点入队次数大于等于N次。

int n,m,ct; bool flag;
int head[maxn],dis[maxn],vis[maxn],cnt[maxn];
struct node{
	int to,next,w;
}e[maxn];
void add(int u,int v,int w){
	ct++;
	e[ct].to=v;
	e[ct].w=w;
	e[ct].next =head[u];
	head[u]=ct;
}
void spfa(){
	queue<int>q;
	for(int i=1;i<=n;i++)
		dis[i]=inf; 
	q.push(0); 
	while(!q.empty()){
		int t=q.front() ;
		q.pop() ; vis[t]=0; 
		for(int i=head[t];i;i=e[i].next){
			int v=e[i].to ; 
			if(dis[v]>dis[t]+e[i].w ){
				dis[v]=dis[t]+e[i].w;
				if(!vis[v]){
					vis[v]=1;
					cnt[v]++;
					if(cnt[v]>=n+1) {//因为加了一个超级源点 所以总点数是N+1
						flag=1; return;
					}
					q.push(v); 
				}
			}
		}
	}
}

int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++){
		int u,v,w;
		scanf("%d%d%d",&u,&v,&w);
		add(v,u,w);
	}
	for(int i=1;i<=n;i++)
		add(0,i,0);
	spfa();
	if(flag){
		printf("NO"); return 0;
	} 
	for(int i=1;i<=n;i++){
		printf("%d ",dis[i]);
	}
	return 0;
}

lca

#include<iostream>
#include<cstdio>
const int N=500005; 
using namespace std;

int n,m,root,ct;
int head[N];
int f[N][30],lg[N],dep[N];
struct node{
	int to,next;
}e[N<<1];

void add(int u,int v){
	ct++; e[ct].to =v;
	e[ct].next=head[u];
	head[u]=ct;
}

void dfs(int p,int fa){
	f[p][0]=fa;
	dep[p]=dep[fa]+1;
	for(int i=1;(1<<i)<=dep[p];i++) //1<<i 别打错了
		f[p][i]=f[f[p][i-1]][i-1];
	for(int i=head[p];i;i=e[i].next )
		if(e[i].to !=fa) dfs(e[i].to ,p); 
}

int lca(int u,int v){
	if(dep[u]<dep[v]) swap(u,v); 
	for(int i=20;i>=0;i--)
        if((1<<i)<=dep[u]-dep[v]) 
            u=f[u][i];
	if(u==v) return v;
	for(int i=20;i>=0;i--)
		if(f[u][i]!=f[v][i]) //注意不等号
			u=f[u][i], v=f[v][i];
	return f[u][0];
}


int main(){
	scanf("%d%d%d",&n,&m,&root);
	for(int i=1;i<n;i++){
		int u,v;
		scanf("%d%d",&u,&v);
		add(u,v); add(v,u);
	}
	dfs(root,0);
	for(int i=1;i<=n;i++)
		lg[i]=lg[i-1]+(1<<lg[i-1]==i);
	for(int i=1;i<=m;i++){
		int u,v;
		scanf("%d%d",&u,&v);
		printf("%d\n",lca(u,v));
	}
	return 0;
	
}

lca+树上差分

const int N=101000;
int n,k,ct,ans,minn=1e9;
int f[N][35],dep[N],lg[N];
int cf[N],head[N];

struct node{
	int to,next;
}e[N];

void add(int u,int v){
	ct++; e[ct].to =v;
	e[ct].next =head[u];
	head[u]=ct;
} 

void dfs(int u,int fa){
	f[u][0]=fa; dep[u]=dep[fa]+1;
	for(int i=1;(1<<i)<=dep[u];i++)
		f[u][i]=f[f[u][i-1]][i-1];
	for(int i=head[u];i;i=e[i].next)
		if(e[i].to!=fa) dfs(e[i].to,u);
}
int lca(int u,int v){
	if(dep[u]<dep[v]) swap(u,v);
	for(int i=20;i>=0;i--)
        if((1<<i)<=dep[u]-dep[v]) 
            u=f[u][i];
	if(u==v) return v;
	for(int i=20;i>=0;i--)
		if(f[u][i]!=f[v][i])
			u=f[u][i], v=f[v][i];
	return f[u][0];
}
void get(int u,int fa){
	for(int i=head[u];i;i=e[i].next ){
		int v=e[i].to ;
		if(v==fa) continue; 
        get(v,u); //不要调错函数
		cf[u]+=cf[v];
	}
	ans=max(ans,cf[u]);
}

int main(){
	cin>>n>>k;
	for(int i=1;i<n;i++){
		int u,v; cin>>u>>v;
		add(u,v); add(v,u);
	}
	dfs(1,0);
	for(int i=1;i<=n;i++)
		lg[i]=lg[i-1]+(1<<lg[i-1]==i);
	for(int i=1;i<=k;i++){
		int u,v; cin>>u>>v;
		int t=lca(u,v);
		cf[f[t][0]]--; cf[t]--;
		cf[u]++; cf[v]++;
	}
	get(1,0);

	printf("%d",ans);
}

欧拉路

欧拉路径判定：

• 有向图欧拉路径：图中恰好存在 1 个点出度比入度多 1（S）， 1 个点入度比出度多 1（T），其余节点出度=入度；或入度=出度。
• 有向图欧拉回路：所有点的入度=出度（起点 S 和终点 T 可以为任意点）。
• 无向图欧拉路径：图中恰好存在 2 个点的度数是奇数，其余节点的度数为偶数，（起点 S 和 终点 T）；或度数都为偶数。
• 无向图欧拉回路: 所有点的度数都是偶数（起点 S 和终点 T 可以为任意点）。

有向图欧拉路板子

int n,m,ct;
int st,ed,ctst,cted;
int in[maxn],ou[maxn],ans[maxn],del[maxn];
int v[maxn],u[maxn];
vector<int>e[maxn];
stack<int>s;
void dfs(int x){
	for(int i=del[x];i<e[x].size();i=del[x]){
		del[x]=i+1;
		int v=e[x][i];
		dfs(v);
	}
	ans[++ans[0]]=x;
}

int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++){
		int u,v;
		scanf("%d%d",&u,&v);
		e[u].push_back(v);
	//	e[v].push_back(u); 
		in[v]++;
		ou[u]++;
	}
	for(int i=1;i<=n;i++)
		sort(e[i].begin() ,e[i].end() );
	bool flag=1;
	for(int i=1;i<=n;i++){
		if(in[i]-ou[i]==1) ed=i,cted++;
		else if(ou[i]-in[i]==1) st=i,ctst++;
		else if(ou[i]!=in[i]) flag=0;
	}

	if(cted>1||ctst>1||ctst!=cted){
		flag=0;
	}
	if(flag==0){
		printf("No"); return 0;
	}	
	if(st==0) st=1;
	dfs(st);
	for(int i=ans[0];i>=1;i--){
		printf("%d ",ans[i]);
	}
}