ACM常用算法打印版Word格式.docx
《ACM常用算法打印版Word格式.docx》由会员分享，可在线阅读，更多相关《ACM常用算法打印版Word格式.docx（67页珍藏版）》请在冰豆网上搜索。
返回值：
阶乘结果的位数
注意：
本程序直接输出n!
的结果，需要返回结果请保留longa[]
需要math.h
源程序：
intfactorial（intn）
{
longa[10000];
inti,j,l,c,m=0,w;
a[0]=1;
for（i=1;
i<
=n;
i++）
{
c=0;
for（j=0;
j<
=m;
j++）
a[j]=a[j]*i+c;
c=a[j]/10000;
a[j]=a[j]%10000;
}
if（c>
0）{m++;
a[m]=c;
}
w=m*4+log10（a[m]）+1;
printf（"
\n%ld"
a[m]）;
for（i=m-1;
i>
=0;
i--）printf（"
%4.4ld"
a[i]）;
returnw;
mult（charc[],chart[],intm）;
c[]：
被乘数，用字符串表示，位数不限
t[]：
结果，用字符串表示
m：
乘数，限定10以内
null
需要string.h
voidmult（charc[],chart[],intm）
inti,l,k,flag,add=0;
chars[100];
l=strlen（c）;
for（i=0;
l;
s[l-i-1]=c[i]-'
0'
;
{
k=s[i]*m+add;
if（k>
=10）{s[i]=k%10;
add=k/10;
flag=1;
}else{s[i]=k;
flag=0;
add=0;
}
}
if（flag）{l=i+1;
s[i]=add;
}elsel=i;
t[l-1-i]=s[i]+'
t[l]='
\0'
mult（chara[],charb[],chars[]）;
a[]：
b[]：
乘数，用字符串表示，位数不限
空间复杂度为o（n^2）
voidmult（chara[],charb[],chars[]）
inti,j,k=0,alen,blen,sum=0,res[65][65]={0},flag=0;
charresult[65];
alen=strlen（a）;
blen=strlen（b）;
alen;
For（j=0;
blen;
j++）res[i][j]=（a[i]-'
）*（b[j]-'
）;
for（i=alen-1;
i--）
for（j=blen-1;
j>
j--）sum=sum+res[i+blen-j-1][j];
result[k]=sum%10;
k=k+1;
sum=sum/10;
for（i=blen-2;
for（j=0;
=i;
j++）sum=sum+res[i-j][j];
if（sum!
=0）{result[k]=sum;
k=k+1;
k;
i++）result[i]+='
for（i=k-1;
i--）s[i]=result[k-1-i];
s[k]='
while
（1）
if（strlen（s）!
=strlen（a）&
&
s[0]=='
）
strcpy（s,s+1）;
else
break;
4.精度计算——加法
add（chara[],charb[],chars[]）;
voidadd（chara[],charb[],charback[]）
inti,j,k,up,x,y,z,l;
char*c;
if（strlen（a）>
strlen（b））l=strlen（a）+2;
elsel=strlen（b）+2;
c=（char*）malloc（l*sizeof（char））;
i=strlen（a）-1;
j=strlen（b）-1;
k=0;
up=0;
while（i>
=0||j>
=0）
if（i<
0）x='
elsex=a[i];
if（j<
0）y='
elsey=b[j];
z=x-'
+y-'
if（up）z+=1;
if（z>
9）{up=1;
z%=10;
}elseup=0;
c[k++]=z+'
i--;
j--;
if（up）c[k++]='
1'
i=0;
c[k]='
for（k-=1;
k>
k--）
back[i++]=c[k];
back[i]='
5.精度计算——减法
sub（chars1[],chars2[],chart[]）;
s1[]：
被减数，用字符串表示，位数不限
s2[]：
减数，用字符串表示，位数不限
默认s1>
=s2，程序未处理负数情况
voidsub（chars1[],chars2[],chart[]）
inti,l2,l1,k;
l2=strlen（s2）;
l1=strlen（s1）;
t[l1]='
l1--;
for（i=l2-1;
i--,l1--）
if（s1[l1]-s2[i]>
=0）
t[l1]=s1[l1]-s2[i]+'
t[l1]=10+s1[l1]-s2[i]+'
s1[l1-1]=s1[l1-1]-1;
k=l1;
while（s1[k]<
0）{s1[k]+=10;
s1[k-1]-=1;
k--;
while（l1>
=0）{t[l1]=s1[l1];
loop:
if（t[0]=='
l1=strlen（s1）;
l1-1;
i++）t[i]=t[i+1];
t[l1-1]='
gotoloop;
if（strlen（t）==0）{t[0]='
t[1]='
conversion（chars1[],chars2[],longd1,longd2）;
s[]：
原进制数字，用字符串表示
转换结果，用字符串表示
d1：
原进制数
d2：
需要转换到的进制数
高于9的位数用大写'
A'
～'
Z'
表示，2～16位进制通过验证
voidconversion（chars[],chars2[],longd1,longd2）
longi,j,t,num;
charc;
num=0;
s[i]!
='
if（s[i]<
9'
s[i]>
）t=s[i]-'
elset=s[i]-'
+10;
num=num*d1+t;
t=num%d2;
if（t<
=9）s2[i]=t+'
elses2[i]=t+'
-10;
num/=d2;
if（num==0）break;
i++;
i/2;
{c=s2[j];
s2[j]=s[i-j];
s2[i-j]=c;
s2[i+1]='
resulet=hcf（inta,intb）、result=lcd（inta,intb）
a：
inta，求最大公约数或最小公倍数
b：
intb，求最大公约数或最小公倍数
返回最大公约数（hcf）或最小公倍数（lcd）
lcd需要连同hcf使用
inthcf（inta,intb）
intr=0;
while（b!
r=a%b;
a=b;
b=r;
return（a）;
lcd（intu,intv,inth）
return（u*v/h）;
8.组合序列
m_of_n（intm,intn1,intm1,int*a,inthead）
组合数C的上参数
n1：
组合数C的下参数
m1：
组合数C的上参数，递归之用
*a：
1～n的整数序列数组
head：
头指针
*a需要自行产生
初始调用时，m=m1、head=0
调用例子：
求C（m,n）序列：
m_of_n（m,n,m,a,0）;
voidm_of_n（intm,intn1,intm1,int*a,inthead）
{
inti,t;
if（m1<
0||m1>
n1）return;
if（m1==n1）
for（i=0;
m;
i++）cout<
<
a[i]<
'
'
//输出序列
cout<
\n'
return;
m_of_n（m,n1-1,m1,a,head）;
//递归调用
t=a[head];
a[head]=a[n1-1+head];
a[n1-1+head]=t;
m_of_n（m,n1-1,m1-1,a,head+1）;
//再次递归调用
9.快速傅立叶变换（FFT）
kkfft（doublepr[],doublepi[],intn,intk,doublefr[],doublefi[],intl,intil）;
pr[n]：
输入的实部
pi[n]：
数入的虚部
n，k：
满足n=2^k
fr[n]：
输出的实部
fi[n]：
输出的虚部
l：
逻辑开关，0FFT，1ifFT
il：
逻辑开关，0输出按实部/虚部；
1输出按模/幅角
voidkkfft（pr,pi,n,k,fr,fi,l,il）
intn,k,l,il;
doublepr[],pi[],fr[],fi[];
intit,m,is,i,j,nv,l0;
doublep,q,s,vr,vi,poddr,poddi;
for（it=0;
it<
=n-1;
it++）
m=it;
is=0;
i<
=k-1;
i++）
{j=m/2;
is=2*is+（m-2*j）;
m=j;
fr[it]=pr[is];
fi[it]=pi[is];
pr[0]=1.0;
pi[0]=0.0;
p=6.283185306/（1.0*n）;
pr[1]=cos（p）;
pi[1]=-sin（p）;
if（l!
=0）pi[1]=-pi[1];
for（i=2;
p=pr[i-1]*pr[1];
q=pi[i-1]*pi[1];
s=（pr[i-1]+pi[i-1]）*（pr[1]+pi[1]）;
pr[i]=p-q;
pi[i]=s-p-q;
=n-2;
it=it+2）
vr=fr[it];
vi=fi[it];
fr[it]=vr+fr[it+1];
fi[it]=vi+fi[it+1];
fr[it+1]=vr-fr[it+1];
fi[it+1]=vi-fi[it+1];
m=n/2;
nv=2;
for（l0=k-2;
l0>
l0--）
m=m/2;
nv=2*nv;
=（m-1）*nv;
it=it+nv）
j<
=（nv/2）-1;
j++）
p=pr[m*j]*fr[it+j+nv/2];
q=pi[m*j]*fi[it+j+nv/2];
s=pr[m*j]+pi[m*j];
s=s*（fr[it+j+nv/2]+fi[it+j+nv/2]）;
poddr=p-q;
poddi=s-p-q;
fr[it+j+nv/2]=fr[it+j]-poddr;
fi[it+j+nv/2]=fi[it+j]-poddi;
fr[it+j]=fr[it+j]+poddr;
fi[it+j]=fi[it+j]+poddi;
fr[i]=fr[i]/（1.0*n）;
fi[i]=fi[i]/（1.0*n）;
if（il!
pr[i]=sqrt（fr[i]*fr[i]+fi[i]*fi[i]）;
if（fabs（fr[i]）<
0.000001*fabs（fi[i]））
if（（fi[i]*fr[i]）>
0）pi[i]=90.0;
elsepi[i]=-90.0;
else
pi[i]=atan（fi[i]/fr[i]）*360.0/6.283185306;
result=integral（doublea,doubleb）;
积分上限
积分下限
functionf：
积分函数
f在（a,b）之间的积分值
functionf（x）需要自行修改，程序中用的是sina（x）/x
默认精度要求是1e-5
doublef（doublex）
returnsin（x）/x;
//在这里插入被积函数
doubleintegral（doublea,doubleb）
doubleh=b-a;
doublet1=（1+f（b））*h/2.0;
intk=1;
doubler1,r2,s1,s2,c1,c2,t2;
doubles=0.0;
doublex=a+h/2.0;
while（x<
b）
s+=f（x）;
x+=h;
t2=（t1+h*s）/2.0;
s2=t2+（t2-t1）/3.0;
if（k==1）
k++;
h/=2.0;
t1=t2;
s1=s2;
c2=s2+（s2-s1）/15.0;
if（k==2）{
c1=c2;
k++;
t1=t2;
r2=c2+（c2-c1）/63.0;
if（k==3）{
r1=r2;
h/=2.0;
while（fabs（1-r1/r2）>
1e-5）{
c1=c2;
returnr2;
result=js（ints[][],intn）
s[][]：
行列式存储数组
行列式维数，递归用
行列式值
函数中常数N为行列式维度，需自行定义
intjs（s,n）
ints[][N],n;
intz,j,k,r,total=0;
intb[N][N];
/*b[N][N]用于存放，在矩阵s[N][N]中元素s[0]的余子式*/
if（n>
2）
for（z=0;
z<
n;
z++）
n-1;
j++）
for（k=0;
k<
k++）
if（k>
=z）b[j][k]=s[j+1][k+1];
elseb[j][k]=s[j+1][k];
if（z%2==0）r=s[0][z]*js（b,n-1）;
/*递归调用*/
elser=（-1）*s[0][z]*js（b,n-1）;
total=total+r;
elseif（n==2）
total=s[0][0]*s[1][1]-s[0][1]*s[1][0];
returntotal;
12.求排列组合数
result=P（longn,longm）;
/result=longC（longn,longm）;
排列组合的上系数
排列组合的下系数
排列组合数
符合数学规则：
m<
＝n
longP（longn,longm）
longp=1;
while（m!
{p*=n;
n--;
m--;
returnp;
longC（longn,longm）
longi,c=1;
i=m;
while（i!
{c*=n;
i--;
{c/=m;
returnc;
二、字符串处理
replace（charstr[],charkey[],charswap[]）;
str[]：
在此源字符串进行替换操作
key[]：
被替换的字符串，不能为空串
swap[]：
替换的字符串，可以为空串，为空串表示在源字符中删除key[]
默认str[]长度小于1000，如否，重新设定设定tmp大小
voidreplace（charstr[],charkey[],charswap[]）
intl1,l2,l3,i,j,flag;
chartmp[1000];
l1=strlen（str）;
l2=strlen（key）;
l3=strlen（swap）;
=l1-l2;
flag=1;
l2;
if（str[i+j]!
=key[j]）{flag=0;
break;
if（flag）
strcpy（tmp,str）;
strcpy（&
tmp[i],swap）;
tmp[i+l3],&
str[i+l2]）;
strcpy（str,tmp）;
i+=l3-1;
result=strfind（charstr[],charkey[]）;
在此源字符串进行查找操作
被查找的字符串，不能为空串
如果查找成功，返回key在str中第一次出现的位置，否则返回-1
intstrfind（charstr[],charkey[]）
intl1,l2,i,j,flag;
升级会员 