一：大整数乘法问题
package 算法;
public class BigIntegerMultiplication {
public static void main(String[] args) {
long x=12345678;
long y=12345678;
// System.out.println(x*y);//152415765279684
long product =multi(x,y,4);
System.out.println(product);//152415765279684
}
//每执行一次multi()函数，都将4个n/2变为3个n/2,逐渐使复杂度降低
private static long multi(long x, long y, int n) {
//n表示的是深度,也就是数字的个数
if(x==0||y==0){
return 0;
}
if(n==1){
return x*y;
}
long A=(long)(x/Math.pow(10,n/2));//12
long B =(long)(x-A*Math.pow(10,n/2));//34
long C=(long)(y/Math.pow(10,n/2));//12
long D =(long)(y-C*Math.pow(10,n/2));//34
long E =multi(A,C, n/2);
long F =multi(B,D,n/2);
long G =multi(A+B,C+D,n/2);
return (long)( E *Math.pow(10,n)+(G-E-F)*Math.pow(10,n/2)+F);
}
}
二：全排列问题
ABC的全排列有：
ABC，ACB，BAC,BCA,CBA,CAB
代码如下：
package 算法;
import java.util.TreeSet;
public class FullPermutation {
private static TreeSet<String> set =new TreeSet<>();
public static void main(String[] args) {
String s="ABB";
char [] arr=s.toCharArray();
permutition(arr,0,arr.length-1);
}
private static void permutition(char[] arr, int from, int to) {
if(from==to){
// System.out.println( String.valueOf(arr));
set.add(String.valueOf(arr));
for(String ss:set){
System.out.println(ss);
}
}
for(int i=from;i<=to;i++){
swap(arr,i,from);
permutition(arr,from+1,to);
swap(arr,i,from);//换了之后还必须要换回来，主要是为了不要影响下一轮的交换
}
}
private static void swap(char[] arr, int i, int from) {
char temp=arr[i];
arr[i]=arr[from];
arr[from]=temp;
}
}
棋盘覆盖问题
三:棋盘覆盖的问题
package 算法;
import java.util.Scanner;
/**
* 利用分治法将方形棋盘分为四个部分
* 如果该特殊点在其中的某一部分，我们就接着去递归处理即可
* 如果该不存在特殊点的部分，我们就假设一个特殊点，同样的去递归下去即可
* 直到全覆盖为止
* 左上角的棋盘，若不存在特殊点，该棋盘的右下角为特殊点
* 右上角的棋盘，若不存在特殊点，该棋盘的左下角为特殊点
* 左下角的棋盘，若不存在特殊点，该棋盘的上角为特殊点
* 右下角的棋盘，若不存在特殊点，该棋盘的左上角为特殊点
*/
public class ChessboardCoverage {
//定义一个棋盘的大小
private static int BOARD_SIZE=8;
//定义一个二维数组模拟棋盘
private static int[][]board =new int [BOARD_SIZE][BOARD_SIZE];
//定义一个骨牌的编号
private static int title =0;
public static void main(String[] args) {
Scanner input =new Scanner(System.in);
System.out.println("棋盘的大小:"+BOARD_SIZE);
System.out.println("输入特殊方格的行号:");
int dr =input.nextInt();
System.out.println("输入特殊方格的列号:");
int dc=input.nextInt();
//开始用递归解决问题
chessBoard(0,0,dr-1,dc-1,BOARD_SIZE);
}
private static void chessBoard(int tr, int tc, int dr, int dc, int size) {
//i,i2指的是方形的左上角的坐标
//dr，dc指的是特殊方格的坐标
//size指的是当前方格的尺寸
if (BOARD_SIZE == 1) {
return;
}
//当前层级下的骨牌编号
int num = ++title;
//方格的尺寸
int s = BOARD_SIZE / 2;
//1，左上角
if (dr < tr + s && dc < tc + s) {
chessBoard(tr, tc, dr, dc, s);
} else {
//特殊方格不在左上角
board[tr + s - 1][tc + s - 1] = num;
chessBoard(tr, tc, tr + s - 1, tc + s - 1, s);
}
//2，右上角
if (dr < tr + s && dc >= tc + s) {
chessBoard(tr, tc + s, dr, dc, s);
} else {
//特殊方格不在左上角
board[tr + s - 1][tc + s] = num;
chessBoard(tr, tc + s, tr + s - 1, tc + s, s);
}
//3，坐下角
if (dr >= tr + s && dc < tc + s) {
chessBoard(tr + s, tc, dr, dc, s);
} else {
//特殊方格不在左下角
board[tr + s][tc + s - 1] = num;
chessBoard(tr + s, tc, tr + s, tc + s - 1, s);
}
//4 右下角
if (dr >= tr + s && dc >= tc + s) {
chessBoard(tr + s, tc + s, dr, dc, s);
} else {
//特殊方格不在左上角
board[tr + s][tc + s] = num;
chessBoard(tr + s, tc + s, tr + s, tc + s, s);
}
}
private static void print(){
for(int i=0;i<BOARD_SIZE;i++){
for(int j=0;j<BOARD_SIZE;j++){
System.out.print(board[i][j]);
}
System.out.println();
}
}
}
四，汉诺塔问题
package 算法;
public class Hanoi {
public static void main(String[] args) {
String x="X";
String y="Y";
String z="Z";
hanota(64,x,y,z);
}
private static void hanota(int level, String begin, String mid, String end) {
if(level==1){
System.out.println(begin+"----->"+end);
}
else{
hanota(level-1,begin,end,mid);
//第level层的
System.out.println(begin+"----->"+end);
hanota(level-1,mid,begin,end);
}
}
}