[学习笔记][算法]算法小技巧（Java）（添加中...）

1、最大公约数-欧几里得算法（辗转相除法）

就是辗转相除法的实现。

//计算a、b的最大公约数
int gcd(int a,int b){
	return b==0?a:gcd(b,a%b);
}

2、最小公倍数

int lcm(int a,int b){
	return (a*b)/gcd(a,b);
}
int gcd(){...}//最大公约数 函数

3、快速幂 O(logn)

假设求 3⁵（x^y），把指数换成二进制，就成了 3¹⁰¹
我们从后向前遍历指数，

1. 首先是 1 （二进制与运算 y&1 ，判断当前位是1还是0），代表结果res 需要乘 3¹ ，直接用 res *= x；同时让 y 右移一位（y >>= 1）；同时 x *=x （因为下一位 是x² ）
2. 第二位是 0 ，无需对 res 运算，直接执行 y 右移；x 扩增（ x *= x 因为下一位是 初始x⁴）
3. 第三位是 1，res *= x 【此时的 x 已经是初始的4次了】；y >>=1 ;x *= x；

三个循环 结束，相比将连续乘 少了两次。

//求x^y,(费马小定理求 1/a 模 p 的逆元 qpom(a,p-2,p))
long qpom(long x, long y, long mod){
	long res = 1l;
	while(y!=0){
		if((y&1)==1)res = res*x%mod; //%mod，添加mod在这里；PS:&优先级小于==，加括号
		y >>= 1;
		x = x*x%mod;//%mod，添加mod 
	}
	return res;
}

4、矩阵快速幂

矩阵x 的 y次，
首先是矩阵和矩阵的乘法规则，a * b 要 ((a的第一行 乘以 b的第一列) 的和) 作为 结果矩阵的第一行一列的值。
剩余快速幂和之前一样，只不过乘法变成了，乘矩阵。（矩阵乘法支持乘法结合律）

//a*b
int[][] Matrix(int[][] a,int[][] b){
    int n=a.length;
    int[][] temp=new int[n][n];
    for(int i=0;i<n;++i)
        for(int j=0;j<n;++j)
            for(int k=0;k<n;++k)
                temp[i][j]=temp[i][j]+a[i][k]*b[k][j];//%mod
    return temp;
}
//qpom x^y
int[][] qpom(int[][] x,int y){
    int[][] res=new int[x.length][x.length];
    for(int i=0;i<x.length;++i)res[i][i]=1;
    while(y!=0){
        if((y&1)==1)res=Matrix(res,x);
        y>>=1;
        x=Matrix(x,x);
    }
    return res;
}

5、最大的 不大于A的 B的倍数

有点绕嘴，求 最大的不大于16的3的倍数，答案应该是15。
15是 （小于16的 （3的倍数））里最大的。

int c = A/B*B;

PS：在java中 A%B == A-A/B*B

6、求组合数 $C_n^m$

首先 $C_n^m$ = $C_n^{n-m}$，可以减少 操作次数
$C_n^m$ = $\frac{n\ast (n-1)\ast (n-2)\ast ...\ast (n-m+1)}{1\ast 2\ast 3\ast ...\ast m}$ = $\frac{n}{1}$ * $\frac{n-1}{2}$ * … *$\frac{n-m+1}{m}$ =

long C(long n, long m){
	if(m>n-m) m=n-m;
	long res = 1l;
	for(int i=1;i<=m;++i,--n){
		res = res*n/i;
	}
	return res;
}

7、求 $k^p$ 有多少位

$10^n$ 的位数是 n+1 位，例如 $10^2$ 为100，有三位（1、0、0）;
k ，可以写成 $10^{lo{g}_{10}k}$，
这样 $k^p$ = $(10^{lo{g}_{10}k}{)}^p$ = $10^{p\ast lo{g}_{10}k}$，所以位数是$1+p\ast lo{g}_{10}k$
PS：这个和进制没关系，因为二进制的2，写成也是“10”，八进制的八也是“10”，最后的效果一样。

int cnt = (int)(p*Math.log10(k)+1);

假如 k 是十进制，但是求 转化成m进制 的位数。参考上方，变成$m^{p\ast lo{g}_{m}k}$

int cnt = (int)(p*(Math.log(k)/Math.log(m))+1);

8、Eluer 欧拉素数筛

任何一个合数都能分解成一个质数乘另一个数
所以筛质数时，可使用这项筛除之后出现的合数。

boolean[] noPrime = new boolean[num+1];//合数为true，num是筛[2,num]之间的素数
int[] prime = new int[num+1];//存储素数
int EluerTop = 0;//prime的边界，因为会有多余零

void Eluer(int num){
	for(int i=2;i<=num;++i){//因为从素数合数最小就是2
		if(!noPrime[i]) prime[EluerTop++] = i;//添加素数
		for(int j=0;j<EluerTop;++j){
			if(i*prime[j] > num) break;//超出范围，直接停下
			noPrime[i*prime[j]] = true;//合数为true
			if(i%prime[j] == 0) break;//避免重复给一个合数赋值。就拿4%2==0来说，在这之前可定有3*2=6这个合数，那么4*3可以为6*2，就没必要在这步给12赋值了。
		}
	}
}

9、位运算快速求一个正整数 二进制下1的个数

可以假设一下，二进制10100减去1，就是把低位上第一个1和后边的零进行了取反，变成10011，
此时两数与运算 得到10000，
去掉了低位第一个1，也就是说有一个1，
那么只要与运算结果不为零，就继续下去

int getCnt(int num){
	int cnt = 0;
	while(num != 0){
		num &= num - 1;//num=(-num^num)# 不用加减的纯位运算
		/**
		 * 这里需要说一下-num的问题，不是单纯符号位取反！！！
		 * 举例：-1 为 11111111111111111111111111111111
		 * 因为 -1 + 1 = 0，二进制0为0000...00，1为0000...01，
		 * 由此可知-1为1111...11
		 * 只有这样 -1 + 1才能一直进位 把所有1 变成0，
		 **/
		++cnt;
	}
	return cnt;
}

10、位运算 判断一个数能否被二整除

boolean can(int num){
	return (num&1)==0;//注意==优先级大于&，加括号
}

11、原地算法（不使用额外空间 交换两个数）

位运算异或 ^，相同为0，不同为1；
以下的代码，可以自己画两个圈圈，取交集啥的。

void swap(int a,int b){//假交换，没有改变传入值，这里只是演示
	a = a^b;//此时a是1的位置为ab的不相交部分
	b = a^b;//此时b是1的位置为a的部分
	a = a^b;//实现交换
}

注意！当两者为同一个变量时，原地算法为零。举例：

• int[] a = new int[]{1,2}；swap(a[0],a[0]);交换中a[0]变为零。
• int a=1,b=1；swap(a,b);只是值相同，并非同一个变量时 没有影响，结果都还是1。

12、位运算 计算从1到n连续异或运算的值 O(1)

看着代码研究一天没明白，看了网上的解析：
首先是几个理论：

1. 0异或任何值，都是那个值本身。
2. ^满足交换律和结合律
3. 连续的异或，看相同位数的1的个数，偶数个最后此位为0，奇数为1。举例
   1（001）
   2（010）
   3（011）
   4（100）
   最低位有两个 ，中间有两个，最高位有一个，所以异或结果为4（100）
4. k>1，从1连续异或到$2^k-1$，结果为$0$（可以试试，因为对应1位置的个数都是偶数）

定义：$f(m,p)$=$m$^ $\cdots$ ^$p$ （从m异或到p）
我们需要计算$f(1,n)$，

假设n>=4，$f(0,n)=f(0,2^k-1)$ ^ $f(2^k,n)，k>1$
前边理论1234，使得上式$=0$ ^ $f(2^k,n)=f(2^k,n)$
之间有$m=n+1-2^k$个数，相当于二进制最高位第（k+1）位有m个（写写二进制就知道了）

1. 假如n为奇数，那么m为偶数，最高位异或完是0。$f(2^k,n)=f(0,n-2^k)$
   $n-2^k$为与$n$的相同，递推下去，得到$=f(0,n$%$4)$
2. n为偶数，m就为奇数，说明最高位是1，相当于上式基础再多异或一个$2^k$，$f(2^k,n)=f(0,n-2^k)$ ^ $2^k=f(0,n$%$4)$ ^ $2^k$，然后其他的和上边一样

综上：
$f(1,n)=f(0,n)=$

$n，n$%$4==0$

$1，n$%$4==1$

$n+1，n$%$4==2$

$0，n$%$4==3$

int oneToN(int n){
	int t = n&3;
	if((t&1)==1)return t>>1^1;
    return t>>1^n;
}

13、欧拉函数

在数论，对正整数n，欧拉函数是小于或等于n的正整数中与n互质的数的数目（因此φ(1)=1）。

int phi(int n) {
	int m = (int) Math.sqrt(n + 0.5);
	int res = n;
	for(int i=2;i<=m;++i) {
		if(res%i==0) {
			res *=(i-1)/i;
			while(n%i==0)n/=i;
		}
	}
	if (n>1)res*=(n-1)/n;
	return res;
}