#Violent recursion and dynamic planning

Result of n

1. Train of thought: n! , first find (n-1)! ，n*(n-1)! That is n! The result. Requirement (n-1)! , first······
2. Code

   public class Factorial {
       public static int factorial(int num) {
           if (num == 1) {
               return 1;
           }
           return factorial(num - 1) * num;
       }
   
       public static void main(String[] args) {
           System.out.println(factorial(3));
       }
   }
   
   

Hanoi Tower problem

1. Title: printing the whole process of the n-story Hanoi tower moving from the leftmost to the rightmost
2. Thinking: three steps

• First, move layer 1-n-1 from the left to the middle
• Move layer n from left to right
• Finally, move the 1~n-1 layer from the middle to the far right

1. Code

   /**
    * Hanoi Tower problem
    */
   public class Hanoi {
       public static void hanoi(int N, String from, String to, String help) {
           if (N == 1) {
               System.out.println("move 1 from" + from + "to" + to);
           } else {
               hanoi(N-1,from,help,to);
               System.out.println("move"+ N +"from"+from+"to"+to);
               hanoi(N-1,help,to,from);
           }
       }
   
   
       public static void main(String[] args) {
           hanoi(3,"Left","right","in");
       }
   }
   
   

Print all subsequences of a string, including empty strings

1. Idea: starting from the first position of the string, each time you traverse to a certain position, there are two values for the position, one is to take the character of the position, the other is to take the empty.
2. Code:

   public class PrintAllSubsquences {
   
       /**
        * Print all subsequences of a string, including empty strings
        * @param str
        */
       public static void printAllSubsquences(String str) {
           char[] chars = str.toCharArray();
           process(chars,0,"");
       }
   
       public static void process(char[] chars,int i,String res) {
           if (i == chars.length) {
               System.out.println(res);
               return;
           }
           process(chars,i+1,res);
           process(chars,i+1,res+chars[i]);
       }
   
   
       public static void main(String[] args) {
           String test = "abc";
           printAllSubsquences(test);
       }
   }
   
   

Every year, a cow is born to a cow, and a new cow can also be born to a cow every year after three years of growth, assuming that it will not die. Ask for the number of cows after N years.

1. Idea: when the number of the year is greater than 3 years, the number of cattle in a certain year = the number of cattle 3 years ago + the number of cattle 1 year ago, because newborn calves can only have calves 3 years later.
2. Code

   /**
    * A cow gives birth to a cow every year, and a new cow can give birth to a cow every year after three years of growth
    * Cow, if not dead. Ask for the number of cows after N years.
    */
   
   public class Cow {
       public static int cowNum(int year) {
           if (year < 0) {
               return 0;
           }
           if (year == 1 || year == 2 || year == 3) {
               return year;
           } else {
               return  cowNum(year - 1) + cowNum(year - 3);
           }
   
       }
   
   
       public static void main(String[] args) {
           System.out.println(cowNum(20));
       }
   }
   
   

Here's an array, AR, and an integer, aim. If you can select any number in the arr, can you accumulate it to get aim and return true or false

1. Idea: similar to the problem of finding all subsequences.
2. Code

   public class IsSum {
   
       public static boolean isSum(int[] arr,int sum, int aim,int i) {
           if (i==arr.length) {
               return sum==aim;
           }
           return isSum(arr, sum, aim, i + 1) || isSum(arr,sum+arr[i],aim,i+1);
       }
   
       public static void main(String[] args) {
           int[] arr = { 1, 4, 8 };
           int aim = 5;
           System.out.println(isSum(arr, 0,aim,0));
   
       }
   }