Java编程算法基础---整除性问题

认识整除和余数的一些规律，可以帮助我们简化计算，提高算法效率。


( a  +  b ) %  c = ( a % c  + b % c ) % c

( a  *  b)  %  c = ( ( a % c ) * ( b % c) ) % c

在数学中，辗转相除法，又称欧几里得算法，是求最大公约数的算法。

辗转相除法首次出现于欧几里得的《几何原本》（第VII卷，命题yⅠ和Ⅱ）中，

而在中国则可以追溯至东汉出现的《九章算术》。
两个整数的最大公约数是能够同时整除它们的最大的正整数。辗转相除法基于如下原理：
两个整数的最大公约数等于其中较小的数和两数的相除余数的最大公约数。

例如，252和105的最大公约数是21（252 = 21 × 12；105 = 21 × 5）；因为252 / 105 = 2余42，所以105和42的最大公约数也是21。

在这个过程中，较大的数缩小了，所以继续进行同样的计算可以不断缩小这两个数直至余数变为零。这时的除数就是所求的两个数的最大公约数。

利用以上特性,可以先对中间结果进行取模操作,从而降低计算规模
1.求解最大公约数的方法
------1.1一般的解法
暴力破解法,从较小的数字开始,逐渐的向下枚举,直到找到能同时整除两个数的数
 

package JavaBasic20DIGUI;

public class Test3Level2 {

	
	static int gcd(int m ,int n){
		int min = -1,max = -1;
		int result = -1;
		if(m == n)
			return m;
		else {
		   if(m > n){
			max = m; min = n;
		   }
		   else if(m < n){
			max = n; min = m;
		   }
			//result = m;
		   for(int i = 1;i <= min ;i++){
			
			  if(max % i == 0 && min % i == 0)
				result = i;
			
		    }
		 return result;
	  }
	}
	public static void main(String[] args){
	
		
		System.out.println(gcd(10, 10));
		
		
	}
}

------1.2.利用辗转相除法来求解最大公约数
若 a > b
 a % k  == 0
 b % k  == 0
则可以推出:  ( a  - b  ) % k == 0
                      ( a % b ) % k == 0 

package NO5;
public class Test3 {

	static int f(int x,int y){
		if(x == 0)
			return y;
		if(y == 0)
			return x;
		if(x < y)  //假若x < y,则 x可能是最大公约数,若y % x != 0,
			       //则辗转,公约数为 比x小的数,调用f(x,y%x)   y%x的值肯定比x小
			return f(x, y%x);
		else 
			return f(y, x%y); 
		           //若 x >= y, 则y可能是最大公约数,若x % y != 0
	               //则辗转,公约数为比y小的数,调用f(y,x%y)   x%yd的值肯定比y小
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

简化版本:

package NO5;

public class Test4 {

	static int f(int x, int y){ //总是假设y是最小的
		if(y == 0) return x;
	
		return f(y, x%y); //若x < y, 则这里可以讲其调换位置
	                      //如 f(5,10) --> f(10,5)
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        System.out.println(f(3,7));
		
	}

}

 
这个问题可能会涉及到证明问题,在递归中很多时候程序员所需要做的就是把一个大问题分解成相同形式的小问题,并且有满足条件的出口,
要对递归有个信任= =\\\\
关于这个算法的证明过程过些日子贴在下面= =

2.求100的阶乘%97
----2.1
   求10的阶乘%97

package NO5;

public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int a = 1;
		for(int i = 1;i <= 10;i++)
			a = (a * i);
		   //a = (a * i) % 97 即在中间过程中就对a进行%操作 
		System.out.println(a % 97);	
	}

}

10的阶乘较小,若求100的阶乘时候,在中间过程就%处理,则很必要了

package NO5;

public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		long currentTime = System.nanoTime();
		int a = 1;
		for(int i = 1;i <= 100;i++)
			a = (a * i);
		   //a = (a * i) % 97 即在中间过程中就对a进行%操作 
		System.out.println(a % 97);	
		long endtime = System.nanoTime();
		System.out.println(endtime - currentTime);
		
		currentTime = System.nanoTime();
		a = 1;
		for(int i = 1;i <= 100;i++)
			a = (a * i)% 97;
		   //a = (a * i) % 97 即在中间过程中就对a进行%操作 
		System.out.println(a % 97);	
		endtime = System.nanoTime();
		System.out.println(endtime - currentTime);
		
	}

}

结果:
0
252468
0
47209
使用%后,效率提高了不少