#在java中使用递归思想解决斐波那契数，猴子吃桃子，汉诺塔，八皇后

#在java中使用递归思想解决斐波那契数，猴子吃桃子，汉诺塔，八皇后

#1.斐波那契数

  //斐波那契数
import java.util.Scanner;
public class Practice {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入数字");
            int n = scanner.nextInt();
            T t1 = new T();
            int fbnq =  t1.fibonacci(n);
            System.out.println(" 当n= "+n+" 对应的斐波那契数= "+fbnq);
        }
}
class T {
    /*
    斐波那契数:1,1,2,3,5,8,13.....
    思路分析
    1.当n=1时,斐波那契数是 1
    2.当n=2时,斐波那契数是 1
    3.当n>=3时,斐波那契数是前两个数之和
     */
    public int fibonacci(int n){
        if(n>=1){
            if(n==1||n==2){
                return 1;
            }else {
                return fibonacci(n-1)+fibonacci(n-2);
            }
        }else {
            System.out.println("输入的数字不符合要求，请重新输出");
            return -1;
        }
    }
}

#2.猴子吃桃子

   //猴子吃桃子
import java.util.Scanner;
public class Practice {
        public static void main(String[] args) {
            T t1 = new T();
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入天数");
            int day = scanner.nextInt();
            int peachNum=t1.peach(day);
            if(peachNum!=-1){
                System.out.println("第"+day+"天有"+peachNum+"个桃子");
            }
        }
}
class T {
    /*
    思路分析
    1.day = 10时 有 1 个桃子
    2.day = 9时 有 (day10+1)*2 = 4 个桃子
    3.day = 8时 有 (day9+1)*2 = 10  个桃子
    4.规律：前一天的桃子=（后一天的桃子+1）*2
     */
        public int peach(int day) {
            if (day == 10) {//第10天，只有一个桃
                return 1;
            } else if (day >= 1 && day <= 9) {
                return (peach(day + 1) + 1) * 2;
            } else {
                System.out.println("day在1-10");
                return -1;
            }
        }
    }

#3.汉诺塔

            //汉诺塔
import java.util.Scanner;
public class Practice {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
           System.out.println("请输入需要移动的个数");
            int moves = scanner.nextInt();
          Tower tower = new Tower();
       int countt = tower.move(moves,'A','B','C');
        System.out.println("一共移动了"+countt+"步");

    }
}
class Tower {
    //num表示要移动的个数 a,b,c分别表示A塔，B塔，C塔
    public int move(int num,char a,char b,char c){
        int count = 0;//这里的count是用来统计移动了多少步
        //如果只有一个盘num = 1
        if(num==1){
            System.out.println(a+"->"+c);
            count++;
        }else{
            //如果有多个盘，可以看成两个，最下面和最上面的所有盘（num-1）
            //（1）先移动上面所有的盘到b，借助c
            move(num-1,a,c,b);
            //（2）把最下面的这个盘，移动到c
            count++;
            System.out.println(a+"->"+c);
            //（3）再把B塔的所有盘，移动到c，借助a
            move(num-1,b,a,c);
            count++;
        }
        return count;
    }
}

#4.八皇后

/*
思路分析
1.第一个皇后先放在第一行第一列
2.第二个皇后放在第二行第一列，然后判断是否OK，如果不OK，继续放在第二列，第三列，依次把所有列都放完，找到一个合适的
3.继续第三个皇后，还是第一列，第二列。。。知道第八个皇后也能放在一个不冲突的位置，算是找到了一个正确解
4.当得到一个正确解，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解决，全部得到
5.然后回头继续第一个皇后放在第二列，后面继续循坏执行1，2，3，4的步骤
说明:理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题 arr[8]={0,4,7,5,2,6,1,3}
对应arr下标表示第几行，即第几个皇后，arr怕[i]=val，val表示第i+1个皇后，放在第i+1行的第val+1列
 */
import java.util.Scanner;
public class Practice {
    static int tol = 0,n;
    static int C[] ;
    static Scanner scan = new Scanner(System.in);
    public static void main(String[] args) {
        n = scan.nextInt();
        C = new int[n];
        for(int j=0;j<n;j++){
            C[j] = 0;
        }

        search(0);
        System.out.println(tol);

    }
    private static void search(int cur) {
        if(cur == n){
            tol++;
            System.out.println("第"+tol+"种放法：");
            for(int i = 0;i< n;i++){
                for(int i1 = 0;i1< n;i1++){
                    if(C[i] == i1)
                        System.out.print('Q');
                    else
                        System.out.print('+');
                }
                System.out.println();
            }
            System.out.println();
        }else {
            for(int j = 0;j<n;j++){
                int ok = 1;
                C[cur] = j;
                for(int k = 0;k<cur ;k++){
                    if(C[k] == C[cur] || C[k] - k ==C[cur]-cur || C[cur] + cur == C[k] + k ){
                        ok = 0;
                        break;
                    }
                }
                if(ok==1)search(cur+1);
            }
        }
    }
}