ACM JAVA+C常用方法模板
//测试时间！！！！！！
放开头：long star=System.currentTimeMillis();
放结尾：System.err.println(System.currentTimeMillis()-star);
//JAVA将字符串拆分放入数租.(截取字符串：截取第i个位置到第i+1个位置的字符串)
String a = "abc";
String[] arr = new String[a.length()];
for(int i = 0; i <arr.length; i++)
{ arr[i] = a.substring(i, (i+1));}
//数组输出：System.out.println(Arrays.toString(arr));
//文件读入将整形放入数组内
Scanner scanner=new Scanner(new File("a.in"));
int n=0,i=0;
n=scanner.nextInt();
int[] arr=new int[n];
for(;i<n;i++)
{arr[i]=scanner.nextInt();}
//将字符串从数组brr的a开始到arr的b点的n+1处结束
System.arraycopy(brr,a, arr, b, n+1);
//将字符串一个个放入数组
char []arr =a.toCharArray();
//字符串比较
字符串a.equals(字符串b);
//如何将字串 String 转换成整数 int
1). int i = Integer.parseInt([String]);
2). int i = Integer.valueOf(my_str).intValue();
//int 转换成字串 String
1.) String s = String.valueOf(i);
2.) String s = Integer.toString(i);
3.) String s = "" + i;
//String型转换为float||float型转换为String型
s.floatValue();||f.toString();
十进制转成十六进制：
Integer.toHexString(int i)
十进制转成八进制
Integer.toOctalString(int i)
十进制转成二进制
Integer.toBinaryString(int i)
十六进制转成十进制
Integer.valueOf("FFFF",16).toString()
八进制转成十进制
Integer.valueOf("876",8).toString()
二进制转十进制
Integer.valueOf("0101",2).toString()
进制转换如何写（二，八，十六）不用算法
Integer.toBinaryString
Integer.toOctalString
Integer.toHexString
//大写转小写，A=65，a=97,Z=90，z=122,0=48；
if(a>=65&&a<=90){
a+=32;
System.out.println((char)a); }
.toLowerCase();//转成小写
.toUpperCase();//转成大写
//动态数组ArrayList
定义： ArrayList <类型> 名字 = new ArrayList<类型>();（两种类型必须一致）
//或者 定义： List list = new ArrayList();
//然后可以添加元素 ；记住，index 从0开始
list.add(0,数字);
//获取list中第2个元素
String ele = list.get(2);
//索引查找
list.indexOf(查找的字);
//返回指定索引处的char值。索引范围是从0到length()-1。对于数组索引，序列的第一个char值是在索引为0，索引1，依此类推。
String.charAt();
//对ArrayList里的元素排序
Collections.sort(list);
//如果用“.”或"|"作为分隔的话,必须是如下写法,String.split("\\."),或("\\|")这样才能正确的分隔开,不能用String.split("."),或("\\|");
String.split()方法,返回是一个数组
String[] aa = "aaa|bbb|ccc".split(" ");
//读取一行，并去掉所有空格
String str=scanner.nextLine().replace(" ","");
//纵向显示整数：
public static void writeVertical(int number)
{
if(number<10){
System.out.println(number);}
else{
writeVertical(number/10);
System.out.println(number%10); }}
//最大公约数：能同时被两个数整出的最大数字叫做最大公约数。
static int gcd(int a,int b)
{if(b == 0)return a;
else
return gcd(b,a%b);}
n利用计算最大公约数的三条性质，用递归方法计算两个整数的最大公约数。?
n性质1：如果x>y，则x和y的最大公约数与x-y和y的最大公约数相同，即 gcd(x,y)=gcd(x-y,y)??? x>y
n性质2：如果y>x，则x和y的最大公约数与x和y-x的最大公约数相同，即 gcd(x,y)=gcd(x,y-x)???? x<y
n性质3：如果x=y，则x和y的最大公约数与x值和y值相同，即 gcd(x,y)=x=y
//裴波那契数（黄金分割数组）前两项只和等于后一项。
static int f(int n) {
if(n==1 || n==2) return 1; // 递归出口
return f(n-1) + f(n-2);}
StringBuffer的常用方法.
StringBuffer类中的方法主要偏重于对于字符串的变化，例如追加、插入和删除等，这个也是StringBuffer和String类的主要区别。
a、append方法
public StringBuffer append(boolean b)
该方法的作用是追加内容到当前StringBuffer对象的末尾，类似于字符串的连接。调用该方法以后，StringBuffer对象的内容也发生改变，例如：
StringBuffer sb = new StringBuffer(“abc”);
sb.append(true);
则对象sb的值将变成”abctrue”。
b、deleteCharAt方法
public StringBuffer deleteCharAt(int index)
该方法的作用是删除指定位置的字符，然后将剩余的内容形成新的字符串。例如：
StringBuffer sb = new StringBuffer(“Test”);
sb. deleteCharAt(1);
该代码的作用删除字符串对象sb中索引值为1的字符，也就是删除第二个字符，剩余的内容组成一个新的字符串。所以对象sb的值变为”Tst”。
还存在一个功能类似的delete方法：
public StringBuffer delete(int start,int end)
该方法的作用是删除指定区间以内的所有字符，包含start，不包含end索引值的区间。
c、insert方法
public StringBuffer insert(int offset, boolean b)
该方法的作用是在StringBuffer对象中插入内容，然后形成新的字符串。例如：
StringBuffer sb = new StringBuffer(“TestString”);
sb.insert(4,false);
该示例代码的作用是在对象sb的索引值4的位置插入false值，形成新的字符串，则执行以后对象sb的值是”TestfalseString”。
d、reverse方法
public StringBuffer reverse()
该方法的作用是将StringBuffer对象中的内容反转，然后形成新的字符串。例如：
StringBuffer sb = new StringBuffer(“abc”);
sb.reverse();
经过反转以后，对象sb中的内容将变为”cba”。
e、setCharAt方法
public void setCharAt(int index, char ch)
该方法的作用是修改对象中索引值为index位置的字符为新的字符ch。例如：
StringBuffer sb = new StringBuffer(“abc”);
sb.setCharAt(1,’D’);
则对象sb的值将变成”aDc”。
//如计算水仙花数：
int sum=0
for(int i=100;i<10000;i++)
{
int j=i;
int b;
do
{ b=j%10; //得到尾数
sum+=Math.pow(b,3);求b的3次方==>把每一次末尾的数的3次方 加起来
j=j/10; // 得到剩下的数
}while(j>0); 直到这个数 被依次 取完 为止
if(sum==j)//如果满足 每一位数的3次方之和等于本身 就是水仙花数了
{ System.out.Print("水仙花数"+j); } }
//java.lang.Math 类包含的方法进行基本的数字操作，如基本的指数，对数，平方根和三角函数等.
abs(xx)
返回绝对值
atan2(double a, double b)
将矩形坐标 (x, y) 转换成极坐标 (r, theta)
ceil(double a)
返回最小的（最接近负无穷大）double 值，该值大于或等于参数，并且等于某个整数
log(double a)
返回（底数是 e）double 值的自然对数
max(int a, int b)
返回两个 int 值中较大的一个
min(int a, int b)
返回两个 int 值中较小的一个
pow(double a, double b)
返回第一个参数的第二个参数次幂的值
random()
返回带正号的 double 值，大于或等于 0.0，小于 1.0
rint(double)
返回其值最接近参数并且是整数的 double 值
round(float)
返回最接近参数的 int
round(double)
返回最接近参数的 long
sin(double)
返回角的三角正弦
sqrt(double)
返回正确舍入的 double 值的正平方根
byte :字节类型值，长度8位（一个字节），范围-128至127。
short：短整型值，长度16位（两个字节），范围-32768至32767。
int：整型值，长度32位（四个字节），范围-2147483648至2147483647
long：长整型，长度64位（八个字节），范围-9223372036854775808至 9223372036854775807
float：单精度浮点数，长度32位（四个字节）。
double：双精度浮点数，长度64位（八个字节）。
char：字符型，长度16位，支持所有的UCS-2和ASCII编码。
对于ACMer还有BigInteger,BigDecimal,String三个类经常使用.
Bignteger
返回值 成员函数
BigInteger add(BigInteger val)
返回其值为 (this + val) 的 BigInteger。
BigInteger subtract(BigInteger val)
返回其值为 (this - val) 的 BigInteger。
BigInteger multiply(BigInteger val)
返回其值为 (this * val) 的 BigInteger。
BigInteger divide(BigInteger val)
返回其值为 (this / val) 的 BigInteger。
BigInteger mod(BigInteger m)
返回其值为 (this mod m) 的 BigInteger。
int compareTo(BigInteger val)
将此 BigInteger 与指定的 BigInteger 进行比较。
如果和val相等返回0,小于返回-1,大于返回1
BigInteger pow(int exponent)
返回其值为 (this exponent) 的 BigInteger。
String toString()
返回此 BigInteger 的十进制字符串表示形式。
String toString(int radix)
返回此 BigInteger 的给定基数的字符串表示形式。
static BigInteger valueOf(long val)
返回其值等于指定 long 的值的 BigInteger。
BigInteger gcd(BigInteger val)
返回一个 BigInteger，其值是 abs(this) 和 abs(val) 的最大公约数。
BigInteger abs()
返回其值是此 BigInteger 的绝对值的 BigInteger。
int hashCode()
返回此 BigInteger 的哈希码。
boolean isProbablePrime(int certainty)
如果此 BigInteger 可能为素数，则返回 true，如果它一定为合数，则返回 false。
BigInteger nextProbablePrime()
返回大于此 BigInteger 的可能为素数的第一个整数。
int signum()
返回此 BigInteger 的正负号函数。
除了以上成员函数,BigInteger还有几个非常常用的属性
BigInteger.ZERO BigInteger 的常量 0。
BigInteger.ONE BigInteger 的常量 1。
BigInteger.TEN BigInteger 的常量 10。
BigDecimal
返回值 成员函数
BigDecimal add(BigDecimal augend)
返回一个 BigDecimal，其值为 (this + augend)。
BigDecimal subtract(BigDecimal subtrahend)
返回一个 BigDecimal，其值为 (this - subtrahend)。
BigDecimal multiply(BigDecimal multiplicand)
返回一个 BigDecimal，其值为 (this × multiplicand).
BigDecimal divide(BigDecimal divisor)
返回一个 BigDecimal，其值为 (this / divisor).
BigDecimal pow(int n)
返回其值为 (thisn) 的 BigDecimal，准确计算该幂，使其具有无限精度。
int compareTo(BigDecimal val)
将此 BigDecimal 与指定的 BigDecimal 比较。
static BigDecimal valueOf(double val)
使用 Double.toString(double) 方法提供的 double 规范的字符串
表示形式将 double 转换为 BigDecimal。
BigDecimal stripTrailingZeros()
返回数值上等于此小数，但从该表示形式移除所有尾部零的 BigDecimal。
String toPlainString()
返回不带指数字段的此 BigDecimal 的字符串表示形式。
String toString()
返回此 BigDecimal 的字符串表示形式，如果需要指数，则使用科学记数法。
BigDecimal abs()
返回 BigDecimal，其值为此 BigDecimal 的绝对值，其标度为 this.scale()。
int hashCode()
返回此 BigDecimal 的哈希码。
int signum()
返回此 BigDecimal 的正负号函数。
函数：add, subtract,divide, mod, compareTo等，其中加减乘除模都要求是BigInteger(BigDecimal)和BigInteger(BigDecimal)之间的运算，所以需要把int(double)类型转换为BigInteger(BigDecimal)，用函数BigInteger.valueOf().
数论
数论 9
高精度算法[1] 11
高精度加法 12
高精度减法 12
高精度乘法 14
整型常量阶乘 15
整型常量阶乘和 16
基于比较的排序算法 17
插入排序 17
选择排序 17
冒泡排序 17
堆排序 18
归并排序 19
快速排序 19
希尔排序 20
计算a^n mod k 21
阶乘最后非0位 21
素数篇 22
费马小定理 22
MR素性测试 22
欧拉函数问题 23
巴赫猜想 23
最大公约数 25
最小公倍数 25
公因数和公倍数 25
stein算法求最大共约数 26
不定方程求解 26
全组合排列 27
非重复组合排列 29
类循环组合排列 30
普通选择性组合排列 31
生成全子集组合排列 32
非重复生成全子集组合排列 32
计算几何 34
三角形面积计算 34
对于任意多边形求面积 34
判断两线是否相交 35
二分查找模板 35
动态规划 36
求局部最大和模板 36
常用的数学公式[4] 36
中国剩余定理 36
基本几何公式 37
欧拉公式 38
划分问题： 39
卡特兰数 39
原理: 39
等比数列 39
等差数列 40
二次函数 40
二次方程 41
约瑟夫环 41
多边形面积 41
(a/b)%m 41
泰勒公式 42
乘法与因式分解公式 42
三角不等式 42
某些数列的前n项和 42
二项式展开公式 43
三角函数公式 43
高精度算法[1]
int Judge(char ch[])
{//判断字符串ch是否全为0，若全为0，返回0，否则返回1
int i,k;
k=strlen(ch);
for(i=0;i<k;i++)
if(ch[i]!='0')
return 0;
return 1;
}
int Compare(char a[],char b[])
{//比较字符串的大小，方法不同于strcmp函数，类似于整型常量的比较
int lena,lenb,i;
lena=strlen(a);
lenb=strlen(b);
if(lena<lenb)
return -1;
else if(lena>lenb)
return 1;
else
{
if(strcmp(a,b)==0)
return 0;
else
{
for(i=0;i<lena;i++)
{
if(a[i]>b[i])
return 1;
if(a[i]<b[i])
return -1;
}
return 0;
}
}
}
高精度加法
/*算法：先确定a和b中的最大位数k，然后依照由低至高位的顺序进行加法运算。注意进位，若高位有进位，则c的长度为k+1。*/
void BigNumberAdd(char a1[],char b1[])
{
int i,j,k,lena,lenb;
int a[1000]={0},b[1000]={0},d[1000]={0};
lena=strlen(a1);
lenb=strlen(b1);
//将加数与被加数化为整型数组，并且该数组的其他位为
for(i=0;i<lena;i++)
a[i]=a1[lena-i-1]-'0';
for(i=0;i<lenb;i++)
b[i]=b1[lenb-1-i]-'0';
//当数组除了加数和被加数以外的整型数组元素均为0时，无需考虑lena和lenb的大小
k=lena>lenb?lena:lenb;
for(i=0;i<k;i++)
{
d[i]=a[i]+b[i]+d[i];
d[i+1]=d[i+1]+d[i]/10;
d[i]=d[i]%10;
}
//若高位进
while(d[k])
k++;
while(!d[k-1])
k--;//001+0003=4
//将整型数组逆着转变并赋值给c字符型数组
for(j=0;j<k;j++)
c[j]=d[k-j-1]+'0';
if(Judge(c))//若全为0，则只输出一个
strcpy(c,"0");
}
高精度减法
/*算法：依照由低位至高位的顺序进行减法运算。在每次位运算中，若出现不够减的情况，则向高位借位。在进行了la的减法后，若最高位为0，则a的长度减。若A、B大小未知，则需先判断大小。*/
void BigNumberSub(char a1[],char b1[])
{//a1为被减数，b1为减数
int lena,lenb,i,j,k,flag;
int a[1000]={0},b[1000]={0},d[1000]={0};
lena=strlen(a1);
lenb=strlen(b1);
if(Compare(a1,b1)>=0)
{//若被减数大于等于减数
for(i=0;i<lena;i++)
a[i]=a1[lena-1-i]-'0';
for(i=0;i<lenb;i++)
b[i]=b1[lenb-1-i]-'0';
flag=0;//结果正的标志
}
else
{//若被减数小于减数
for(i=0;i<lenb;i++)
a[i]=b1[lenb-1-i]-'0';
for(i=0;i<lena;i++)
b[i]=a1[lena-1-i]-'0';
flag=1;//结果负的标志
}
k=lena>lenb?lena:lenb;
for(i=0;i<k;i++)
{//大数减小数
if(a[i]<b[i])
{//若被减数不够减，向高位借一位
a[i+1]--;
d[i]=a[i]-b[i]+10;
}
else
d[i]=a[i]-b[i];
}
//若较高位已为0，并且不止1位时
while(!d[i-1])
{
k--;
i--;
}
//根据flag，输出有无"-"
if(!flag)
{
for(i=0;i<k;i++)
{//将结果转化为字符逆着赋给数组c
if(!i&&!d[k-i-1])//若差的第一个字母为0，则马上跳过
continue;
c[i]=d[k-i-1]+'0';
}
}
else
{
c[0]='-';
for(i=1;i<=k;i++)
{//将结果转化为字符逆着赋给数组c
if(i==1&&!d[k-i])//若差的第一个字母为0，则马上跳过
continue;
c[i]=d[k-i]+'0';//注意d的下标，不是k-i-1
}
}
if(Judge(c))//若差全为0，则只输出一个
strcpy(c,"0");
}
高精度乘法
高精度乘以低精度
/*算法：将多位数存入数组，低位在前、高位在后，然后用一位数去乘数组的各位，考虑进位，最后按正常顺序输出*/
void BigNumMultiSmall(char a1[],int b1)
{
int i,j,t;
int a[2000]={0};
//将字符串转化为整型数组，并逆置
t=strlen(a1);
for(i=0;i<t;i++)
a[i]=a1[t-1-i]-'0';
//整型数组的每个元素乘以b1，然后对其进行求余，整除，使其只有一位数
a[0]=a[0]*b1;
for(i=1;i<t;i++)
{
a[i]*=b1;
a[i]+=a[i-1]/10;
a[i-1]=a[i-1]%10;
}
while(a[i-1]>9)
{//若最后一个元素大于9
a[i]=a[i-1]/10;
a[i-1]=a[i-1]%10;
i++;
}
//将得到的整型数组逆置赋给字符串
for(j=0;j<i;j++)
c[j]=a[i-j-1]+'0';
if(Judge(c))//若积全为0，则只输出一个0
strcpy(c,"0");
}
高精度乘以高精度
void BigNumMultiBig(char a1[],char b1[])
{
int i,j,k,lena,lenb;
int a[1000]={0},b[1000]={0},d[2000]={0};
//将字符串转化为整型数组，并逆置
lena=strlen(a1);
lenb=strlen(b1);
for(i=0;i<lena;i++)
a[i]=a1[lena-i-1]-'0';
for(i=0;i<lenb;i++)
b[i]=b1[lenb-i-1]-'0';
//计算乘数从低位到高位以此乘以被乘数的低位到高位
for(i=0;i<lena;i++)
for(j=0;j<lenb;j++)
{
d[i+j]=d[i+j]+a[i]*b[j];
d[i+j+1]+=d[i+j]/10;
d[i+j]=d[i+j]%10;
}
//根据高位是否为判断整型数组的位数
k=lena+lenb;
while(!d[k-1])
k--;
//积转化为字符型
for(i=0;i<k;i++)
c[i]=d[k-1-i]+'0';
if(Judge(c))//若积全为0，则只输出一个1
strcpy(c,"0");
}
整型常量阶乘
void BigNumFact(int x)
{
int i,k,m=0,a[1000]={0};
a[0]=1;
for(;x;x--)
{//m为在求阶乘过程中a的元素个数
for(k=i=0;i<=m;i++)
{
k=k+a[i]*x; //数组各个元素均乘以x(x递减)，以完成阶乘的运算
a[i]=k%10;
k/=10;
}
while(k)
{
a[++m]=k%10;
k/=10;
}
}
//阶乘的结果转化为字符型
for(i=0;i<=m;i++)
c[i]=a[m-i]+'0';
if(Judge(c))//若结果全为，则只输出一个
strcpy(c,"0");
}
整型常量阶乘和
void BigNumFactAdd(int t) //可以改进，减少算法时间复杂度
{
int i;
char sum[2000],d[2000];
//对字符串进行初始化
memset(d,0,sizeof(d));
memset(sum,0,sizeof(sum));
//分别求出相应i的阶乘然后相加
for(i=t;i>0;i--)
{
BigNumFact(i); //调用大数乘法。可以减少时间复杂度
strcpy(d,c);
memset(c,0,sizeof(c));
BigNumberAdd(d,sum);
strcpy(sum,c);
memset(c,0,sizeof(c));
}
strcpy(c,sum);//将结果赋值给全局变量，进行输出
}
基于比较的排序算法
#include <iostream>
using namespace std;
#define SWAP(i,j) {int t=(i);(i)=(j);(j)=t;}
插入排序
void InsertSort(int*a,int len) //算法主体函数
{
for (int i=1;i<len;i++)
{
int j=i,x=a[i];
while (j && a[j-1]>x)
a[j]=a[j-1],j--;
a[j]=x;
}
}
/********************************/
选择排序
void SelectSort(int*a,int len) //算法主体函数
{
for (int i=1,j,k;i<len;i++)
{
for (j=i,k=i-1;j<len;j++)
if (a[j]<a[k])
k=j;
if (k>=i)
SWAP(a[i-1],a[k]);
}
}
/********************************/
冒泡排序
void BubbletSort(int*a,int len) //算法主体函数
{
for (bool bSwap=true;bSwap;len--)
{
bSwap=false;
for (int j=1;j<len;j++)
if (a[j-1]>a[j])
{
SWAP(a[j-1],a[j]);
bSwap=true;
}
}
}
/********************************/
堆排序
//堆调整
void HeapAdjust(int *a,int root,int len)
{
int child,x=a[root];
while (child=root<<1|1,child<len)
{
if (child<len-1 && a[child]<a[child+1])
child++;
if (x<a[child])
{
a[root]=a[child];
root=child;
}
else
break;
}
a[root]=x;
}
//堆排序
void HeapSort(int*a,int len) //算法主体函数
{
for (int i=len/2-1;i>=0;i--)
HeapAdjust(a,i,len);
while (--len)
{
SWAP(a[0],a[len]);
HeapAdjust(a,0,len);
}
}
/********************************/
归并排序
//归并
void Merge(int*a,int len1,int len2)
{
int *a1=new int[len1+1],*a2=new int[len2+1],len=len1+len2;
for (int i=0;i<len1;i++)
a1[i]=a[i];
for (int i=0;i<len2;i++)
a2[i]=a[len1+i];
a1[len1]=a2[len2]=INT_MAX;
for (int i=0,j=0,k=0;k<len;k++)
if (a1[i]<a2[j])
a[k]=a1[i++];
else
a[k]=a2[j++];
delete[] a1;delete[] a2;
}
//归并排序
void MergeSort(int*a,int len) //算法主体函数
{
if (len>1)
{
int c=len/2;
MergeSort(a,c);
MergeSort(a+c,len-c);
Merge(a,c,len-c);
}
}
/********************************/
快速排序
//划分
int Partition(int*a,int len)
{
int x=a[--len],i=-1;
for (int j=0;j<len;j++)
if (a[j]<x)
{
i++;
SWAP(a[i],a[j]);
}
SWAP(a[i+1],a[len]);
return i+1;
}
//快速排序
void QuickSort(int*a,int len) //算法主体函数
{
if (len > 0)
{
int q=Partition(a,len);
if (q<len-q)
{
QuickSort(a,q-1);
QuickSort(a+q+1,len-q-1);
}
else
{
QuickSort(a+q+1,len-q-1);
QuickSort(a,q-1);
}
}
}
/***********插入式希尔排序****************/
希尔排序
//希尔插入
void ShellInsert(int*a,int inc,int len)
{
for (int i=inc;i<len;i+=inc)
{
int j=i,x=a[i];
while (j>0 && a[j-inc]>x)
a[j]=a[j-inc],j-=inc;
a[j]=x;
}
}
//插入式希尔排序
void ShellSort(int*a,int len) //算法主体函数
{
int inc=len;
do
{
inc=inc/3+1;
for(int s=0;s<inc;s++)
ShellInsert(a-s,inc,len+s);
}
while (inc>1);
}
/********************************/
计算a^n mod k
int powmod( int a, int n, int k )
阶乘最后非0位
const int mod[20]={1,1,2,6,4,2,2,4,2,8,4,4,8,4,6,8,8,6,8,2};
int len=strlen(buf),a[MAXN],i,c,ret=1;
ret=ret*mod[a[1]%2*10+a[0]]%5;
素数篇
除了1和此整数自身外，没法被其他自然数整除的数，又称质数。
void prim()
{
long i,j,k;
prime[0]=2;
prime[1]=3;
jue[2]=true;
jue[3]=true;
jue[5]=true;
for(i=5,k=2;i<999983;i+=2)
{
for(j=0;prime[j]*prime[j]<=i&&i%prime[j];)
{
j++;
if(prime[j]*prime[j]>i)
{
prime[k++]=i;
jue[i]=true;
}
}
}
}
//暴力判素数
bool isprime(int p) {
for(int i=2;i*i<=p;i++) if(p%i==0)return 0;
return 1;
}
费马小定理
若p为素数，a为正整数，那么一定有a^p≡a(Mod p)
MR素性测试
给定整数a，若满足a^p≡a(Mod p)，p为一个素数，则a很可能也是素数
欧拉函数问题
#include<stdio.h>
int main()
{
long n,i,k;
double r;
while(scanf("%ld",&n)&&n)
{
r=n;
i=2;
while(n>1)
{
k=0;
while(n%i==0)
{
n/=i;
k=1;
}
if(k)
r*=1.0-1.0/i;
if(i==2)
i++;
else
i=i+2;
}
printf("%.0lf\n",r);
}
return 0;
}
巴赫猜想
/*
哥德巴赫猜想:每一个数最多可由3个素数相加表示，任意一个大于4的偶数必定可以表示为两奇素数之和
*/
#include<stdio.h>
int cnt,n,tmp;
int ff[10001],f[10001],b[10001],primes[3000];
void prime()
{
int i,j,t;
for(i=0;i<10001;i++)
ff[i]=0;
for(i=2;i<=100;i++)
{
if(ff[i])
continue;
j=i*i;
while(j<=10000){
ff[j]=1;
j+=i;
}
}
cnt=0;
for(i=2;i<=10000;i++)
if(ff[i]==0)
primes[cnt++]=i;
for(i=0;i<10001;i++)
f[i]=-1;
f[0]=0;
for(i=0;i<cnt;i++)
{
t=primes[i];
for(j=t;j<=3*t;j++)
{
/***************和包含t的数中，最小为t，最大为t+t+t
if(j>10000)
break;
if(f[j-t]!=-1&&(f[j]==-1||f[j]>f[j-t]+1))
{
f[j]=f[j-t]+1;
b[j]=t; } }} }
int main()
{prime();
while(scanf("%d",&n)!=EOF)
{if(n<=1)
printf("0\n");
else
{if(ff[n]==0)
{printf("1\n");
printf("%d\n",n);
continue;
}
else
{printf("%d\n",f[n]);
while(n>0)
{
printf("%d",b[n]);
n-=b[n];
if(n==0)
printf("\n");
else
printf(" ");
}}} }
return 0;}
最大公约数
int gcd(int a , int b) //递归实现
{
return (b? gcd(b , a%b ) : a);
}
int gcd(int a , int b) //非递归实现
{
while (b){ int t = a % b; a = b; b = t; }
return a;
}
最小公倍数
lcm(a,b) = a/gcd(a,b)*b
公因数和公倍数
int GCD(int x, int y)
{
int temp;
if(x < y)
{
temp = x; x = y; y = temp;
}
while(y != 0)
{
temp = y;
y = x % y;
x = temp;
}
return x;
}
int beishu(int x, int y)
{
return x * y / GCD(x,y);
}
stein算法求最大共约数
不定方程求解
二元线性不定方程：形如ax + by = c
不定方程求解程序：对于方程ax + by = gcd(a, b)
void euclid_gcd(int a , int b , int & d , int & x , int & y)
{
if (!b){ d = a; x = 1; y = 0; }
else {
euclid_gcd(b , a%b , d , y , x );
y -= x*(a/b);
}
}
全组合排列
方法一：
#define MAX_N 10
int n; //共n个数
int rcd[MAX_N]; //记录每个位置填的数
int used[MAX_N]; //标记数是否用过
int num[MAX_N]; //存放输入的n个数
void full_permutation(int L)
{
int i;
if (L == n+1)
{ //输出
return;
}
for (i=1; i<=n; i++)//枚举所有的数，循环从0开始
if (!used[i]) { //num[i]没有使用过
used[i] = 1; //标记为已使用
rcd[L] = i; //在l位置放上该数
full_permutation(L+1); //填下一个位置
used[i] = 0; //清标记
}
}
方法二：
#include <iostream>
using namespace std;
int x[11]={0,1,2,3,4,5,6,7,8,9,10};
void permute(int t)//全排列
{
if(t>n)
output();
else
{
for(int i = t; i <= n; i++)
{
swap(x[t],x[i]);
permute(t+1);
swap(x[t],x[i]);
}
}
}
测试函数
Sample Input
3
1 2 3
Sample Output
123
132
213
...
//Program
#include<stdio.h>
#include<string.h>
const int maxn=11;
int n;
int used[maxn];//标记数组
int mat[maxn];//存储数组
int num[maxn];//输出数组
void solve(int l)
{
if(l>=n)
{
for(int i=0;i<n;++i)printf("%d", num[i]);
puts("");
return;
}
for(int i=0;i<n;++i)
{
if(!used[i])
{
used[i]=1;
num[l]=mat[i];
solve(l+1);
used[i]=0;
}
}
}
int main()
{
while(scanf("%d", &n)!=EOF)
{
for(int i=0;i<n;++i)scanf("%d", mat+i);
memset(used,0,sizeof(used));
solve(0);
}
return 0;
}
非重复组合排列
含重复数字时，生成不重复组合排列
Sample Input
4
1 2 2 3
Sample Output
1223
1232
1322
...
//Program
#include<stdio.h>
const int maxn=10;
int n,var;
int Index;
int used[maxn],mat[maxn],num[maxn];
void push(int varNum){ //压栈
for(int i=0;i<Index;++i){
if(mat[i]==varNum){
++used[i];
return;
}
}
mat[Index]=varNum;
++used[Index++];
}
void solve(int l){ //求解
if(l>=n){
for(int i=0;i<n;++i)printf("%d", num[i]);
puts("");
return;
}
for(int i=0;i<Index;++i){
if(used[i]){
used[i]--;
num[l]=mat[i];
solve(l+1);
used[i]++;
}
}
}
int main(){
while(scanf("%d", &n)!=EOF){
Index=0;
for(int i=0;i<n;++i){
scanf("%d", &var);
push(var);
}
solve(0);
}
return 0;
}
类循环组合排列
Sample Input：
4 2
Sample Output
0000
0001
0010
....
//Program
#include<stdio.h>
int n,m;
int mat[10];
void solve(int l)
{
if(l>=n)
{
for(int i=0;i<n;++i)
printf("%d", mat[i]);
puts("");
return;
}
for(int i=0;i<m;++i)
{
mat[l]=i;
solve(l+1);
}
}
int main()
{
while(scanf("%d%d", &n, &m)!=EOF)
{
solve(0);
}
return 0;
}
普通选择性组合排列
void solve(int startVar,int selectVar)
for(int i=0;i<selectM;++i)printf("%d", num[i]);
for(int i=startVar;i<totalN;++i)
while(scanf("%d%d", &totalN, &selectM)!=EOF)
for(int i=0;i<totalN;++i)scanf("%d", mat+i);
生成全子集组合排列
void solve(int cur_totalVar,int nextVar)
for(int i=0;i<cur_totalVar;++i)printf("%d", num[i]);
for(int i=0;i<n;++i)scanf("%d",mat+i);
//注意：倘若需要输出空集（也即输出一个换行），可做如下修改
//在函数solve()中，将if(cur_totalVar)puts(""); 改为puts("");
非重复生成全子集组合排列
含重复数字时，生成不重复全子集组合排列
Sample Input
4
1 2 2 3
Sample Output
1
12
122
1223...
//Program
#include<stdio.h>
const int maxn=10;
int n,var;
int Index;
int used[maxn],mat[maxn],num[maxn];
void push(int varNum)
{ //压栈
for(int i=0;i<Index;++i)
{
if(mat[i]==varNum)
{
++used[i];
return;
}
}
mat[Index]=varNum;
++used[Index++];
}
void solve(int l,int p)
{ //求解
for(int i=0;i<l;++i)printf("%d", num[i]);
if(l)puts("");
for(int i=p;i<Index;++i)
{
if(used[i])
{
used[i]--;
num[l]=mat[i];
solve(l+1,i);
used[i]++;
}
}
}
int main()
{
while(scanf("%d", &n)!=EOF)
{
Index=0;
for(int i=0;i<n;++i)
{
scanf("%d", &var);
push(var);
}
solve(0,0);
}
return 0;
}
//注意：倘若需要输出空集（也即输出一个换行），可做如下修改
//在函数solve()中，将if(l)puts(""); 改为puts("");
计算几何
三角形面积计算
//已知三条边和外接圆半径，公式为s = a*b*c/(4*R)
double GetArea(double a, double b, double c, double R)
{
return a*b*c/4/R;
}
//已知三条边和内接圆半径，公式为s = pr
double GetArea(double a, double b, double c, double r)
{
return r*(a+b+c)/2;
}
对于任意多边形求面积
对于平面内的任意一个多边行,我们要求其面积,可以采用这样一来的思想方法:
//万涛的理解:多边形每相邻两点与原点形成的矢量面积(叉积)之和.
double av(double v)
{
if(v<0)
v=-v;
return v;
}
for(i=0; i<n; i++)
{
c=x[i]*y[(i+1)%n]
d=y[i]*x[(i+1)%n];
area+=c;
area-=d;
printf("c=%.2lf\n",c-d);
}
area=av(area)/2;
判断两线是否相交
//判断点在直线的上或下及左或右側.具体是采用点斜式求出一条线段所在直线的方程,然后将点代如求值进行判断
参照网站:计算几何算法概览
double DirectionV3(double x1, double y1, double x2, double y2, double x3, double y3){
return x1*y3+x2*y1+x3*y2-x1*y2-x2*y3-x3*y1;
}
bool Intersect(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
依据:两条线段不相交,必定是存在其中一条线段的两端点在在另一条线段所在直线的同側.所以要分别考虑两种情况.
if(DirectionV3(x1, y1, x2, y2, x3, y3)*DirectionV3(x1, y1, x2, y2, x4, y4)>0)//一条线段的两点全在另一条线段的同一側
return false;
if(DirectionV3(x3, y3, x4, y4, x1, y1)*DirectionV3(x3, y3, x4, y4, x2, y2)>0)//
return false;
return true;
}
一。最佳原理（DP思想的精华）：
假设为了解决某一优化问题，需要依次作出N个决策D1,D2,....,DN.如若这个决策序列是最优的，对于任何一个整数K,1<K<N，不论前面K个决策是怎样的，以后的最优决策只取决于由前面决策所确定的当前状态，即以后的决策DK+1,DK+2,...DN也是最优的。
二分查找模板
//This is a binary-search mode .
int Bsearch(int b,int num[],int n)
{
int mid,l=0,r=n-1;
while(l<=r)
{
mid=(r+l)/2;
if(b<num[min]) r=mid-1; //less than it.
else if(b>num[min]) l=mid+1; //bigger than it.
else return min; //Just find it and return.
}
return -1; //fail to find.
}
动态规划
求局部最大和模板
定义两个变量max,change,对于一维数组a[]中的连续最大和,我们可以采取以下的循环完成.
/*************/
change=0;
max=a[1];
for (i=2;i<=n;i++) //'n' is the lenth of array a[].
{
if (change+a[ i ]>0)
change+=a[ i ]; //"change" is changable
else
{
change=0;
if(max<a[ i ])max=a[ i ];
continue;
}
if (max<change) max=change;
b[ i ]=max;// 如果我们要求1~n 的数的所有的局部最大和.
常用的数学公式[4]
中国剩余定理
一般形式：设m = m1 ，… ，mk 为两两互素的正整数，m＝m1，…mk ，m＝mi
Mi，i＝1，2，… ，k 。则同余式组x≡b1(modm1)，…，x≡bk(modmk)的解为
x≡M'1M1b1＋…＋M'kMkbk （modm）。式中M'iMi≡1 （modmi），i＝1，2，…，k 。
完全数：又称完美数或完备数，是一些特殊的自然数：
它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。
偶完全数公式：2^(n-1)*(2^n-1) ，当且仅当2^n-1为素数，又称梅森素数。
2^n-1为素数的必要条件为n是素数。
基本几何公式
圆柱体的体积公式：体积=底面积×高 ，如果用h代表圆柱体的高，则圆柱＝S底×h
长方体的体积公式：体积=长×宽×高
如果用a、b、c分别表示长方体的长、宽、高则
长方体体积公式为：V长=abc
正方体的体积公式：体积＝棱长×棱长×棱长．
如果用a表示正方体的棱长，则
正方体的体积公式为V正＝a·a·a＝a³
锥体的体积=底面面积×高÷3 V 圆锥＝S底×h÷3
台体体积公式:V=[ S上+√(S上S下)+S下]h÷3
圆台体积公式:V=(R²+Rr+r²)hπ÷3
球缺体积公式＝πh²(3R-h)÷3
球体积公式：V＝4πR³/3
棱柱体积公式：V＝S底面×h＝S直截面×l （l为侧棱长,h为高)
棱台体积：V=〔S1＋S2＋开根号（S1*S2）〕／3*h
注：V：体积；S1：上表面积；S2：下表面积；h：高。
几何体的表面积计算公式
圆柱体:
表面积:2πRr+2πRh 体积:πRRh (R为圆柱体上下底圆半径,h为圆柱体高) 圆锥体:
表面积:πRR+πR[(hh+RR)的平方根] 体积: πRRh/3 (r为圆锥体低圆半径,h为其高, 平面图形
名称 符号 周长C和面积S
正方形 a—边长 C＝4a S＝a2 长方形 a和b－边长 C＝2(a+b) S＝ab 三角形 a,b,c－三边长h－a边上的高s－周长的一半A,B,C－内角其中
s＝(a+b+c)/2 S＝ah/2＝ab/2·sinC ＝[s(s-a)(s-b)(s-c)]1/2＝a2sinBsinC/(2sinA) 四边形 d,D－对角线长α－对角线夹角 S＝dD/2·sinα 平行四边形 a,b－边长h－a边的高α－两边夹角 S＝ah＝absinα 菱形 a－边长α－夹角D－长对角线长d－短对角线长 S＝Dd/2＝a2sinα 梯形 a和b－上、下底长h－高m－中位线长 S＝(a+b)h/2＝mh 圆 r－半径 d－直径 C＝πd＝2πr S＝πr2＝πd2/4 扇形 r—扇形半径 a—圆心角度数 C＝2r＋2πr×(a/360) S＝πr2×(a/360) 弓形 l－弧长 S＝r2/2·(πα/180-sinα)
b－弦长 ＝r2arccos[(r-h)/r] - (r-h)(2rh-h2)1/2
h－矢高 ＝παr2/360 - b/2·[r2-(b/2)2]1/2
r－半径 ＝r(l-b)/2 + bh/2
α－圆心角的度数 ≈2bh/3 圆环 R－外圆半径 S＝π(R2-r2)
r－内圆半径 ＝π(D2-d2)/4
D－外圆直径
d－内圆直径 椭圆 D－长轴 S＝πDd/4
d－短轴
递推问题：三角形l=l+i*(i+1)/2+i/2*(i-i/2)
欧拉公式
（1）分式里的欧拉公式
a＾r/(a-b)(a-c)+b＾r/(b-c)(b-a)+c＾r/(c-a)(c-b)
当r=0,1时式子的值为0 当r=2时值为1
当r=3时值为a+b+c
（2）三角形中的欧拉公式
设R为三角形外接圆半径，r为内切圆半径，d为外心到内心的距离，则： d＾2=R＾2-2Rr
（3）拓扑学里的欧拉公式
V+F-E=X(P)，V是多面体P的顶点个数，F是多面体P的面数，E是多面体P的棱的条数,X(P)是多面体P的欧拉示性数。
（4）初等数论里的欧拉公式
欧拉函数，在数论，对正整数n，欧拉函数是少于或等于n的数中与n互质的数的数目。
此函数以其首名研究者欧拉命名，它又称为Euler's totient function、φ函数、欧拉商数等。
φ函数的值Euler函数通式：φ(x)=x(1-1/p1)(1-1/p2)(1-1/p3)(1-1/p4)…..(1-1/pn),
其中p1, p2……pn为x的所有质因数，x是不为0的整数。
|
三角不等式 |
|a+b|≤|a|+|b| |
|a-b|≤|a|+|b| |
|a|≤b<=>-b≤a≤b |
|||||||||||
|
|a-b|≥|a|-|b| |
-|a|≤a≤|a| |
|||||||||||||
|
一元二次方程的解 |
-b+√(b2-4ac)/2a |
-b-√(b2-4ac)/2a |
||||||||||||
|
根与系数的关系 |
X1+X2=-b/a |
X1*X2=c/a |
注：韦达定理 |
|||||||||||
|
数列前n项和 |
1+2+3+4+5+6+7+8+9+…+n=n(n+1)/2 |
1+3+5+7+9+11+13+15+…+(2n-1)=n2 |
||||||||||||
|
2+4+6+8+10+12+14+…+(2n)=n(n+1) |
12+22+32+42+52+62+72+82+…+n2=n(n+1)(2n+1)/6 |
|||||||||||||
|
13+23+33+43+53+63+…n3=n2(n+1)2/4 |
1*2+2*3+3*4+4*5+5*6+6*7+…+n(n+1)=n(n+1)(n+2)/3 |
|||||||||||||
|
常用数学公式表:解析几何公式 |
||||||||||||||
|
圆的标准方程 |
(x-a)2+(y-b)2=r2 |
注：（a,b）是圆心坐标 |
||||||||||||
|
圆的一般方程 |
x2+y2+Dx+Ey+F=0 |
注：D2+E2-4F>0 |
||||||||||||
|
抛物线标准方程 |
y2=2px |
y2=-2px |
x2=2py |
x2=-2py |
||||||||||
|
常用数学公式表:几何图形公式 |
||||||||||||||
|
直棱柱侧面积 |
S=c*h |
斜棱柱侧面积 |
S=c'*h |
|||||||||||
|
正棱锥侧面积 |
S=1/2c*h' |
正棱台侧面积 |
S=1/2(c+c')h' |
|||||||||||
|
圆台侧面积 |
S=1/2(c+c')l=pi(R+r)l |
球的表面积 |
S=4pi*r2 |
|||||||||||
|
圆柱侧面积 |
S=c*h=2pi*h |
圆锥侧面积 |
S=1/2*c*l=pi*r*l |
|||||||||||
|
弧长公式 |
l=a*r (a是圆心角的弧度数r>0) |
扇形面积公式 |
s=1/2*l*r |
|||||||||||
|
锥体体积公式 |
V=1/3*S*H |
圆锥体体积公式 |
V=1/3*pi*r2h |
|||||||||||
|
柱体体积公式 |
V=s*h |
圆柱体 |
V=pi*r2h |
|||||||||||
|
斜棱柱体积 |
V=S'L (S'是直截面面积，L是侧棱长) |
注：pi=acos(-1.0); |
||||||||||||
划分问题：
卡特兰数
原理:
h(n)= h(0)*h(n-1)+h(1)*h(n-2) + ... + h(n-1)h(0) (其中n>=2)
h(n)=C(2n,n)/(n+1) (n=1,2,3,...)
等比数列
Sn=a1(1-q^n)/(1-q) =(a1-an*q)/(1-q) (q≠1) (q为比值，n为项数）
①若 m、n、p、q∈N，且m＋n=p＋q，则am*an=ap*aq；
(5)"G是a、b的等比中项""G^2=ab（G ≠ 0）".
等差数列
2、 Sn=a1*n+n(n-1)d/2
an=a1+(n-1)d
二次函数
对称轴为直线x = -b/2a，顶点坐标(-b/2a,(4ac-b^2)/4a)。
(两个式子实质一样,但初中课本上都是第一个式子)（若给出抛物线的顶点坐标或对称轴与最值，通常可设顶点式）
（若给出抛物线与x轴的交点及对称轴与x轴的交点距离或其他一的条件，通常可设交点式）
（a，b，c为常数，a≠0，且a决定函数的开口方向，a>0时，开口方向向上，a<0时，开口方向向下。a的绝对值还可以决定开口大小,a的绝对值越大开口就越小,a的绝对值越小开口就越大。）
二次方程
当△>0 ，x1= [-b-sqrt(b*b-4*a*c)]/(2*a)，x2=[-b+ sqrt(b*b-4*a*c)]/(2*a)。
约瑟夫环
令f表示i个人玩游戏报m退出最后胜利者的编号，最后的结果自然是f[n].
有了这个公式，我们要做的就是从1-n顺序算出f的数值，最后结果是f[n]。因为实际生活中编号总是从1开始，我们输出f[n]+1由于是逐级递推，不需要保存每个f，程序也是异常简单：
多边形面积
S=0.5*abs(x1*y2-y1*x2+x2*y3-y2*x3+...+xn*y1-yn*x1)
(a/b)%m
背景：a是b的倍数
1.如果m是质数，很简单，直接用扩展的欧几里德求b关于m的逆元
泰勒公式
乘法与因式分解公式
三角不等式
某些数列的前n项和
二项式展开公式
三角函数公式
1 两角和公式
2 倍角公式
6.5
6.6
3 半角公式
4 和差化积
ACM JAVA+C常用方法模板相关推荐
- java浏览器实验报告_关于java实验报告模板
关于java实验报告模板 1．掌握Java Applet的程序结构和开发过程. 2．学会编写Applet对应的HTML文件,掌握从HTML文件向Applet传递参数的方法. 3. 掌握文本框对象的使用 ...
- java 实验报告模板_Java实验报告模板.doc.doc
Java实验报告模板.doc 实 验 报 告 课程名称Java面向对象程序设计实验名称检查危险品姓名吴超益学号201424134114专业年级14物联网一.实验目的: 本实验的目的是让学生掌握try- ...
- Java Mail+Thymeleaf模板引擎实现发送HTML格式邮件
Java Mail+Thymeleaf模板引擎实现发送HTML格式邮件 基于Spring boot 1.5,Spring boot 2.x请使用Spring boot mail 1.依赖坐标 // b ...
- 【Apache POI】Java Web根据模板导出word文件
最近工作中遇到一个需求:根据word模板文档导出word文件. 查阅了一些资料,发现Apache POI可以实现文档读写的功能,于是就研究了一下,总结如下: Apache-POI在线Javadoc:h ...
- java抽象类和模板模式_测试抽象类和模板方法模式
java抽象类和模板模式 摘自Wikipedia,"模板方法定义了算法的程序框架. 子类可以覆盖一个或多个算法步骤,以允许不同的行为,同时确保仍然遵循总体算法." 通常,此模式由两 ...
- JAVA中.jsp模板文件AJAX异步请求 - 数据渲染问题
JAVA中.jsp模板文件AJAX异步请求 - 数据渲染失败,谁的过失? 后端已经查询出来结果,但是返回的API接口response查看不到对应的信息.(即:后台有,前台没有) 原因分析: 是因为AJ ...
- Java下载excel模板
接上篇 -- "下载功能"实现 Excel模板数据导入 参考 上一篇 : Java实现Excel模板导入 正文: 一.接口层: /*** 下载** @param res respo ...
- java读写word模板_Java操作Word模板插入列表
Java操作Word模板插入列表 通过poi操作word,插入各种编号的列表,包括数字,字母,罗马字符,自定义任意字符.下面的示例就用了音乐符♬. 1.制作模板,插入列表使用语法*,模板内容为{{*n ...
- java 解析word模板为xml, 动态填充数据到xml,最后输出word文档
java 解析word模板为xml, 动态填充数据到xml,最后输出word文档 在项目中, 一开始是使用java Apache poi 根据word模板生成word报表, 后面发现框架有个低版本的p ...
最新文章
- CompletableFuture详解~acceptEither
- CCNA初认识——链路捆绑命令
- n阶方程求逆c语言,n阶方阵求逆
- powerdesigner 16设计mysql数据库_PowerDesigner16 连接MySql 报错
- [erlang] mnesia
- 首发Android 13！谷歌Pixel 7 Pro渲染图曝光：后置相机模组吸睛
- Android HWUI硬件加速模块浅析
- 读SUCH AMERCAN和贾平凹的画集
- 笨鸟先飞之ASP.NET MVC系列之过滤器(04认证过滤器)
- springboot源码解析autoconfigure之AopAutoConfiguration
- 浅谈-国标GB28181协议抓包内容分析（一）
- NAT 穿透是如何工作的：技术原理及企业级实践
- 密码学小知识(1)：布隆过滤器(Bloom Filter)、混淆布隆过滤器（Garbled BF）和布谷鸟过滤器(Cuckoo Filter)
- Java邮件发送（实名发送和匿名发送）
- 如何下载央视网视频，下载视频播放花屏怎么办
- vue 移动端无限瀑布流 插件使用
- 如何计算DDR存储容量
- 不可思议有氧机器人_不思议迷宫奇怪的机器人怎么得？不思议迷宫奇怪的机器人获取一览...
- 多用户商城系统源码_业务逻辑功能思维导图_OctShop
- EditText禁止输入表情