ACM小组内部预定函数.docx
《ACM小组内部预定函数.docx》由会员分享，可在线阅读，更多相关《ACM小组内部预定函数.docx（58页珍藏版）》请在冰点文库上搜索。
ACM小组内部预定函数
ACM小组内部预定函数
Ver2.0byIcyFenix
数学问题：
1.精度计算——大数阶乘
2.精度计算——乘法（大数乘小数）
3.精度计算——乘法（大数乘大数）
4.精度计算——加法
5.精度计算——减法
6.任意进制转换
7.最大公约数、最小公倍数
8.组合序列
9.快速傅立叶变换（FFT）
10.Ronberg算法计算积分
11.行列式计算
12.求排列组合数
字符串处理：
1.字符串替换
2.字符串查找
3.字符串截取
计算几何：
1.叉乘法求任意多边形面积
2.求三角形面积
3.两矢量间角度
4.两点距离（2D、3D）
5.射向法判断点是否在多边形内部
6.判断点是否在线段上
7.判断两线段是否相交
8.判断线段与直线是否相交
9.点到线段最短距离
10.求两直线的交点
11.判断一个封闭图形是凹集还是凸集
12.Graham扫描法寻找凸包
数论：
1.x的二进制长度
2.返回x的二进制表示中从低到高的第i位
3.模取幂运算
4.求解模线性方程
5.求解模线性方程组（中国余数定理）
6.筛法素数产生器
7.判断一个数是否素数
图论：
1.Prim算法求最小生成树
2.Dijkstra算法求单源最短路径
3.Bellman-ford算法求单源最短路径
4.Floyd算法求每对节点间最短路径
排序/查找：
1.快速排序
2.希尔排序
3.选择法排序
4.二分查找
数据结构：
1.顺序队列
2.顺序栈
3.链表
4.链栈
5.二叉树
一、数学问题
1.精度计算——大数阶乘
语法：
intresult=factorial（intn）;
参数：
n：
n的阶乘
返回值：
阶乘结果的位数
注意：
本程序直接输出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;
}
2.精度计算——乘法（大数乘小数）
语法：
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;i s[l-i-1]=c[i]-'0';
for（i=0;i {
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;
for（i=0;i t[l-1-i]=s[i]+'0';
t[l]='\0';
}
3.精度计算——乘法（大数乘大数）
语法：
mult（chara[],charb[],chars[]）;
参数：
a[]：
被乘数，用字符串表示，位数不限
b[]：
乘数，用字符串表示，位数不限
t[]：
结果，用字符串表示
返回值：
null
注意：
空间复杂度为o（n^2）
需要string.h
源程序：
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）;
for（i=0;i for（j=0;j for（i=alen-1;i>=0;i--）
{
for（j=blen-1;j>=0;j--）sum=sum+res[i+blen-j-1][j];
result[k]=sum%10;
k=k+1;
sum=sum/10;
}
for（i=blen-2;i>=0;i--）
{
for（j=0;j<=i;j++）sum=sum+res[i-j][j];
result[k]=sum%10;
k=k+1;
sum=sum/10;
}
if（sum!
=0）{result[k]=sum;k=k+1;}
for（i=0;i for（i=k-1;i>=0;i--）s[i]=result[k-1-i];
s[k]='\0';
while
（1）
{
if（strlen（s）!
=strlen（a）&&s[0]=='0'）
strcpy（s,s+1）;
else
break;
}
}
4.精度计算——加法
语法：
add（chara[],charb[],chars[]）;
参数：
a[]：
被乘数，用字符串表示，位数不限
b[]：
乘数，用字符串表示，位数不限
t[]：
结果，用字符串表示
返回值：
null
注意：
空间复杂度为o（n^2）
需要string.h
源程序：
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='0'; elsex=a[i];
if（j<0）y='0'; elsey=b[j];
z=x-'0'+y-'0';
if（up）z+=1;
if（z>9）{up=1;z%=10;} elseup=0;
c[k++]=z+'0';
i--;j--;
}
if（up）c[k++]='1';
i=0;
c[k]='\0';
for（k-=1;k>=0;k--）
back[i++]=c[k];
back[i]='\0';
}
5.精度计算——减法
语法：
sub（chars1[],chars2[],chart[]）;
参数：
s1[]：
被减数，用字符串表示，位数不限
s2[]：
减数，用字符串表示，位数不限
t[]：
结果，用字符串表示
返回值：
null
注意：
默认s1>=s2，程序未处理负数情况
需要string.h
源程序：
voidsub（chars1[],chars2[],chart[]）
{
inti,l2,l1,k;
l2=strlen（s2）;l1=strlen（s1）;
t[l1]='\0';l1--;
for（i=l2-1;i>=0;i--,l1--）
{
if（s1[l1]-s2[i]>=0）
t[l1]=s1[l1]-s2[i]+'0';
else
{
t[l1]=10+s1[l1]-s2[i]+'0';
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];l1--;}
loop:
if（t[0]=='0'）
{
l1=strlen（s1）;
for（i=0;i t[l1-1]='\0';
gotoloop;
}
if（strlen（t）==0）{t[0]='0';t[1]='\0';}
}
6.任意进制转换
语法：
conversion（chars1[],chars2[],longd1,longd2）;
参数：
s[]：
原进制数字，用字符串表示
s2[]：
转换结果，用字符串表示
d1：
原进制数
d2：
需要转换到的进制数
返回值：
null
注意：
高于9的位数用大写'A'～'Z'表示，2～16位进制通过验证
源程序：
voidconversion（chars[],chars2[],longd1,longd2）
{
longi,j,t,num;
charc;
num=0;
for（i=0;s[i]!
='\0';i++）
{
if（s[i]<='9'&&s[i]>='0'）t=s[i]-'0';elset=s[i]-'A'+10;
num=num*d1+t;
}
i=0;
while
（1）
{
t=num%d2;
if（t<=9）s2[i]=t+'0';elses2[i]=t+'A'-10;
num/=d2;
if（num==0）break;
i++;
}
for（j=0;j
{c=s2[j];s2[j]=s[i-j];s2[i-j]=c;}
s2[i+1]='\0';
}
7.最大公约数、最小公倍数
语法：
resulet=hcf（inta,intb）、result=lcd（inta,intb）
参数：
a：
inta，求最大公约数或最小公倍数
b：
intb，求最大公约数或最小公倍数
返回值：
返回最大公约数（hcf）或最小公倍数（lcd）
注意：
lcd需要连同hcf使用
源程序：
inthcf（inta,intb）
{
intr=0;
while（b!
=0）
{
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）
参数：
m：
组合数C的上参数
n1：
组合数C的下参数
m1：
组合数C的上参数，递归之用
*a：
1～n的整数序列数组
head：
头指针
返回值：
null
注意：
*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;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）;//再次递归调用
t=a[head];a[head]=a[n1-1+head];a[n1-1+head]=t;
}
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输出按模/幅角
返回值：
null
注意：
需要math.h
源程序：
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;
for（i=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;i<=n-1;i++）
{
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;
}
for（it=0;it<=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>=0;l0--）
{
m=m/2;nv=2*nv;
for（it=0;it<=（m-1）*nv;it=it+nv）
for（j=0;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;
}
}
if（l!
=0）
for（i=0;i<=n-1;i++）
{
fr[i]=fr[i]/（1.0*n）;
fi[i]=fi[i]/（1.0*n）;
}
if（il!
=0）
for（i=0;i<=n-1;i++）
{
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;
}
return;
}
10.Ronberg算法计算积分
语法：
result=integral（doublea,doubleb）;
参数：
a：
积分上限
b：
积分下限
functionf：
积分函数
返回值：
f在（a,b）之间的积分值
注意：
functionf（x）需要自行修改，程序中用的是sina（x）/x
需要math.h
默认精度要求是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;
loop:
doubles=0.0;
doublex=a+h/2.0;
while（x {
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;
gotoloop;
}
c2=s2+（s2-s1）/15.0;
if（k==2）{
c1=c2;k++;h/=2.0;
t1=t2;s1=s2;
gotoloop;
}
r2=c2+（c2-c1）/63.0;
if（k==3）{
r1=r2; c1=c2;k++;
h/=2.0;
t1=t2;s1=s2;
gotoloop;
}
while（fabs（1-r1/r2）>1e-5）{
r1=r2;c1=c2;k++;
h/=2.0;
t1=t2;s1=s2;
gotoloop;
}
returnr2;
}
11.行列
升级会员 