Siyao模板库.docx

Siyao模板库.docx

《Siyao模板库.docx》由会员分享，可在线阅读，更多相关《Siyao模板库.docx（21页珍藏版）》请在冰豆网上搜索。

Siyao模板库

Siyao@Sphinx模板库

目录

NumberTheroy1

1、mul_mod同余乘：

避免乘法溢出1

2、GCD算法：

求两数最大公约数已经测试2

3、EX_GCD扩展欧几里德：

递归求ax+by=gcd（a,b）=d的一组解x,y.效率：

o（logn）.2

4、CF_GCD连分数方法解ax=gcd（a,b）mod（b）以及ax+by=gcd（a,b）=d.2

5、msolve（）,inv（）模线性方程和逆元:

解ax=b（modn）.2

6、pow_mod（）快速幂取模：

返回a^nmodp3

7、同余一元方程组（2个）：

返回是否有解，解为x=m（moda）已经测试FZU14023

8、同余一元方程组（剩余定理）：

x=ai（modbi）,bi两两互素。

得到x=x0（modb1……bn）3

9、同余一元方程组（一般情况）：

不停合并两方程3

10、log（）离散对数（模为素数）:

返回满足a^x=b（modn）的最小解，无解返回-14

11、mlist（）筛法得素数表：

intprim[]中保存素数,pnum保存个数，hash可以用bool型4

12、pfact（）分解素因子：

intpf[]中保存素因子intlim[]保存幂次,pfnum保存个数5

13、phi（）,phis（）欧拉函数：

phi求1-n中与n互素的数的个数；phis求1-n所有数的phi5

14、square_free（）筛法生成Square-free数：

intsf[]中存结果，shh[]中存因子数（以便进行容斥）6

15、序列中互质的m元组（容斥原理square-free）：

m元组最大公约数为1已经测试TJU31216

16、区间与数互质（容斥原理dfs）：

求[1,r]区间中与x互质的数的个数已经测试TJU33176

17、区间与区间互质（容斥原理square-free）：

求[1,x],[1,y]互质的对数7

18、区间与区间互质（容斥原理dfs）：

求[1,x],[1,y]互质的对数7

19、枚举约数及对应的欧拉函数：

已经测试HDU25887

20、欧拉函数加速递归函数取模：

已经测试POJ2720TJU33137

21、阶乘中素数的阶已经测试FZU17538

22、C（N,M）modP组合数取模已经测试HIT28138

23、n!

（cop）modP阶乘中与素数互素的部分模p9

24、n!

n!

n!

/n!

n!

n!

n!

多阶乘乘除模k（k为square-free数）9

25、n!

（con）&invmodk阶乘与k互素部分ff以及逆元fv打表已经测试FZU18339

26、sum_mod等比数列求和取模10

27、floor,ceil高斯函数：

取上下整已经测试SGU10610

28、一次不等式求整数解：

L=

29、二元一次方程求整数解对：

ax+by+c=0xl=

30、素数测试之miller-rabin：

返回false则一定是合数已经测试PKU181110

31、素数测试函数：

isprime（n）11

32、Pollard-rho算法对合数找到一个因数已经测试PKU181111

33、分解为素因子的积：

利用Pollard-rho算法（n为1特殊处理了）12

34、Farey逼近分数：

得到分母

35、Pell方程：

x^2-dy^2=1的解12

36、带限制可重排列：

13

NumberTheroy

1、mul_mod同余乘：

避免乘法溢出

typedef__int64ll;

typedefconst__int64cll;

llmul_mod（lla,llb,cll&n）{//二进制思想已经测试PKU1811

llans（0）,tmp（（a%n+n）%n）;b=（b%n+n）%n;//b%=n;

while（b）{

if（b&1）if（（ans+=tmp）>=n）ans-=n;

if（（tmp<<=1）>=n）tmp-=n;

b>>=1;

}returnans;

}

2、GCD算法：

求两数最大公约数已经测试

欧几里得算法.适用非负整数.效率：

o（logn）.

llgcd（lla,llb）{

if（!

a）returnb;if（!

b）returna;

while（a>b?

a%=b:

b%=a）;returna+b;

}

llgcd（lla,llb）{return（b==0?

a:

gcd（b,a%b））;}

llgcd（lla,llb）{if（b）while（b^=a^=b^=a%=b）;returna;}

二进制算法.避免了模运算.大整数时效率较高.o（logn）

llgcd（lla,llb）{

if（!

a）returnb;if（!

b）returna;

if（!

（a&1）&&!

（b&1））returngcd（a>>1,b>>1）<<1;

elseif（!

（b&1））returngcd（a,b>>1）;

elseif（!

（a&1））returngcd（a>>1,b）;

elseif（a

}

3、EX_GCD扩展欧几里德：

递归求ax+by=gcd（a,b）=d的一组解x,y.效率：

o（logn）.

voidgcd（lla,llb,ll&d,ll&x,ll&y）{//已经测试FZU1402

if（!

b）{d=a;x=1;y=0;}

else{gcd（b,a%b,d,y,x）;y-=a/b*x;}

}

4、CF_GCD连分数方法解ax=gcd（a,b）mod（b）以及ax+by=gcd（a,b）=d.

a/b=ak[n-1]-bh[n-1]=（-1）^（n+1）gcd（a,b）

h[-2]=0,h[-1]=1,k[-2]=1,k[-1]=0;

llcfgcd（lla,llb）{//getxofax=d（modb）已经测试FZU1402

intc[40],l=0;

llx1=0,x=1,p=b;

while（b）{c[l++]=a/b;a%=b;a^=b^=a^=b;}

for（inti=0;i

returnl&1?

p-x:

x;

}

voidgcd（lla,llb,ll&d,ll&x,ll&y）{x=cfgcd（a,b）;d=a*x%b;if（!

d）d=b;y=（a*x-d）/b;}

5、msolve（）,inv（）模线性方程和逆元:

解ax=b（modn）.

不定方程：

ax+by=c特解为x0=x*c/d,y0=y*c/d通解x=x0+b/d*t,y=y0-a/d*t

也就是解ax+ny=b的x的通解对模n的剩余系。

答案在c[]数组中。

llmsolve（lla,llb,lln,llc[]）{//besuren>0返回剩余系的个数

lld,x,y;gcd（a,n,d,x,y）;if（b%d）return0;

for（x=（（b/d）*x）%（n/d）,i=0;i

returnd;

}

b=1时x为a的逆元

llinv（lla,lln）{//无逆元返回-1

lld,x,y;gcd（a,n,d,x,y）;

returnd==1?

（x%n+n）%（n/d）:

-1;

}

6、pow_mod（）快速幂取模：

返回a^nmodp

乘法部分需要自己写mul_mod（a,b,p）（a*b%p）避免溢出。

效率o（logn）。

llpow_mod（lla,lln,llp）{

llans

（1）,d（a%p）;

while（n）{

if（n&1）ans=mul_mod（ans,d,p）;//ans=（（longlong）ans*d）%p;

d=mul_mod（d,d,p）;//d=（（longlong）d*d）%p;

n>>=1;

}

returnans;

}

7、同余一元方程组（2个）：

返回是否有解，解为x=m（moda）已经测试FZU1402

boolcombm（ll&a1,ll&m1,lla2,llm2）{//k1m1+a1=k2m2+a2=>k1m1-k2m2=a2-a1

lld,x,y,m,a;gcd（m1,m2,d,x,y）;if（（a2-a1）%d）returnfalse;

//while（a1%m2!

=a2）a1+=m1;m1*=m2/d;returntrue;//暴力也可以

m2/=d;x=（x%m2）*（（a2-a1）/d%m2）%m2;//小心溢出

a1=x*m1+a1;m1*=m2;a1=（a1%m1+m1）%m1;

returntrue;

}

8、同余一元方程组（剩余定理）：

x=ai（modbi）,bi两两互素。

得到x=x0（modb1……bn）

llchina（lla[],llb[],intn）{//解同余方程已经测试FZU1402

lltmp=1,x,y,d,ans=0;

for（inti=0;i

for（inti=0;i

gcd（tmp/b[i],b[i],d,x,y）;

ans=（ans+tmp/b[i]*x*a[i]）%tmp;

}

return（ans+tmp）%tmp;

}

llchina（lla[],llb[],intn）{//试除已经测试FZU1402

llans=a[0]%b[0],tmp=b[0];

for（inti=1;i

=a[i]）ans=ans+tmp;

returnans%tmp;

}

9、同余一元方程组（一般情况）：

不停合并两方程

boolg_solve（lla[],llb[],intn,ll&ans,ll&mod）{//返回是否有解已经测试FZU1402

ans=a[0]%b[0],mod=b[0];

for（inti=1;i

combm（ans,mod,a[i],b[i]））returnfalse;

returntrue;//for（inti=0;i

（1）;

}

10、log（）离散对数（模为素数）:

返回满足a^x=b（modn）的最小解，无解返回-1

structnode{

llv;

llpos;

}mmap[MAX];

intsize=0;

booloperator<（nodea,nodeb）{returna.v

voidinsert（llv,intpos）{

mmap[size].v=v;

mmap[size].pos=pos;

++size;

return;

}

intbsearch（lla）{

intlow=-1,high=size-1;

while（low+1

{

intmid=（low+high）/2;

if（mmap[mid].v

low=mid;

else

high=mid;

}

if（mmap[high].v!

=a）return-1;

returnmmap[high].pos;

}

lllog（lla,llb,lln）{//Baby-Step-Giant-Step,nisprime

intm=（int）ceil（sqrt（n*1.0））;

intv=inv（pow_mod（a,m,n）,n）;

insert（1%n,size=0）;

inte=1,i,k;

for（i=1;i

sort（mmap,mmap+size）;

for（i=0;i

if（（k=bsearch（b））!

=-1）returni*m+k;

return-1;

}

11、mlist（）筛法得素数表：

intprim[]中保存素数,pnum保存个数，hash可以用bool型

constintprimN=31650;//sqrt（10^9）//已经测试FZU1402

intp[primN],hash[primN],pnum=0;

voidmlist（）{

p[pnum++]=2;

for（inti=3;i

if（!

hash[i]）{

p[pnum++]=i;

if（i<10000）for（intj=i*i;j

}

}

12、pfact（）分解素因子：

intpf[]中保存素因子intlim[]保存幂次,pfnum保存个数

intpf[60],pfnum=0,lim[60];//已经测试FZU1402

voidpfact（intn）{

pfnum=0;

for（inti=0;i

if（n%p[i]==0）{

lim[pfnum]=0;

while（n%p[i]==0）n/=p[i],++lim[pfnum];

pf[pfnum++]=p[i];

}

if（n!

=1）lim[pfnum]=1,pf[pfnum++]=n;

}

13、phi（）,phis（）欧拉函数：

phi求1-n中与n互素的数的个数；phis求1-n所有数的phi

llphi（lln）{//已经测试FZU1759

llans=n,i,j=4;

for（inti=2;j<=n;j+=i+i+1,++i）

if（n%i==0）{

ans=ans/i*（i-1）;

while（n%i==0）n/=i;

}

if（n!

=1）ans=ans/n*（n-1）;

returnans;

}

llphi（lln）{//需要素数表已经测试FZU1759

llans=n;

for（inti=0;i

if（n%p[i]==0）{

ans=ans/p[i]*（p[i]-1）;

while（n%p[i]==0）n/=p[i];

}

}

if（n!

=1）ans=ans/n*（n-1）;

returnans;

}

constintphiN=1000001;//已经测试HDU1645TJU3317

intphi[phiN];

voidphis（）{

for（inti=1;i

for（inti=2;i

if（phi[i]==i）

for（intj=i;j

}

14、square_free（）拟筛法生成Square-free数：

intsf[]中存结果，shh[]中存因子数（以便进行容斥）

constintSFN=100001;//已测试TJU3317

intsf[SFN],shh[SFN],sfnum=0;

voidsquare_free（）{

sfnum=shh[1]=0,sf[sfnum++]=1;

for（inti=2;i

if（!

shh[i]）for（intj=i;j

=-1）（j/i）%i==0?

shh[j]=-1:

++shh[j];

if（shh[i]!

=-1）sf[sfnum++]=i;

}

}

15、序列中互质的m元组（容斥原理square-free）：

m元组最大公约数为1已经测试TJU3121

constintnpN=10001;

intnphh[npN];

llnpairco（inta[],intn,intm）{

inti,j,ma,m1,tmp;llans（0）;

for（i=0;i

for（ma=i=0;i

++nphh[a[i]];

if（a[i]>ma）ma=a[i];

}

m1=ma/m;

for（ans=i=0;i

for（tmp=0,j=sf[i];j<=ma;j+=sf[i]）tmp+=nphh[j];

if（tmp>=m）ans+=（shh[sf[i]]&1）?

-c（tmp,m）:

c（tmp,m）;//c（n,k）为组合数

}

returnans;

}

16、区间与数互质（容斥原理dfs）：

求[1,r]区间中与x互质的数的个数已经测试TJU3317

voiddfs（intstep,boolflag,intv,constint&R,int&ans）{

if（v>R）return;

if（step>=pfnum）{

if（v!

=1）ans+=flag?

（R/v）:

-（R/v）;

}

else{

dfs（step+1,flag,v,R,ans）;

if（（ll）v*pf[step]<=R）dfs（step+1,1^flag,v*pf[step],R,ans）;

}

}

intlineco（intr,intx）{//[1,r]中与x互质的个数

pfact（x）;//分解x

intans=（r/x）*phi[x]+r%x;dfs（0,1,1,r%=x,ans）;//欧拉函数加速

//intans=r;dfs（0,1,1,r,ans）;//用这个事先不需要生成phi

returnans;

}

17、区间与区间互质（容斥原理square-free）：

求[1,x],[1,y]互质的对数

有序对：

//已经测试TJU3317

llgridco（lln,llm）{

if（n>m）swap（n,m）;llret=0;

for（inti=0;i

ret+=shh[sf[i]]&1?

-（n/sf[i]）*（m/sf[i]）:

（n/sf[i]）*（m/sf[i]）;//小心溢出

returnret;

}

无序对：

gridco（n,m）-（gridco（n,n）-1）/2（n

18、区间与区间互质（容斥原理dfs）：

求[1,x],[1,y]互质的对数

有序对：

枚举小区间中的数调用lineco已经测试TJU3317

llgridco（intn,intm）{//[1,m]与[1,n]中互质的数对（a,b）!

=（b,a）

if（n>m）swap（n,m）;

llret=0;for（inti=1;i<=n;++i）ret+=lineco（m,i）;

returnret;

}

无序对：

枚举小区间中的数调用lineco减去重复对（注意把1多减的加回）已经测试HDU1695

llgridco（intn,intm）{//[1,m]与[1,n]中互质的数对（a,b）!

=（b,a）

if（n>m）swap（n,m）;if（!

n）return0;//phi[1]=0;

llret=0;for（inti=1;i<=n;++i）ret+=lineco（m,i）-phi[i];

returnret+1;

}

19、枚举约数及对应的欧拉函数：

已经测试HDU2588

pfact（n）;//分解ans=0;//初始化dfs（0,1,1）;//调用

voiddfs（intstep,intv,intphi）{

if（step>=pfnum）;//相应处理

else{

dfs（step+1,v,phi）;

v*=pf[step],phi*=pf[step]-1;

for（inti=1;i<=lim[step];++i）{

dfs（step+1,v,phi）;

v*=pf[step],phi*=pf[step];

}

}

}

20、欧拉函数加速递归函数取模：

已经测试POJ2720TJU3313

a^b（modn）=a^（b>phi（n）?

b%phi（n）+phi（n）:

b）（modn）

intflag=0;

intget（intb,inti,intn）//f（i）%n=b^（f（i-1）%phi（n））POJ2720

{

if（b==1||i==0）return1%n;//出口

intt=get（b,i-1,phi（n））;//返回f（i-1）%phi（n）

if（flag）t+=phi（n）;

longlongtmp=b,ans=1;//要注意如果基数小（0或者1）可能要把flag值变回0

while（t）{

if（t&1）{

ans=ans*tmp;

if（ans>=n）ans%=n,flag=1;

}

tmp=tmp*tmp;

if（tmp>=n）tmp%=n,flag=1;

t>>=1;

}

returnans;

}

intflag=0;

intget（inti,intn）//f（i）%n=（i%10）^（f（i/10）%phi（n））TJU3313

{

if（i==0）return1%n;