About Recursive Functions

The title of the sentence is too long, but in short, it is a task to get a sequence that satisfies "left 」 right".

Recursive is easy to understand if you think about it as follows:

1. In the middle of recursion
·It is in this state now → What should I do next?

2. End Recursive
·Finish when these conditions are met

For a brief illustration of the example presented,

In the middle of recursion:
·The left side of the position you are paying attention to has already been confirmed, so you don't need to consider it
·Put n pieces in the position you are paying attention to → Due to the title, you can put n pieces or less next time, so you can put them down and go one more time to the right by recursing
ending recursive:
·If you can't put it down, don't display it and exit (res<0 is this: the remaining number is not enough)
·Display and exit when placed correctly (res==0 is this: 0 left)
·After placing one, it ends ( for ends)

It was when Oira understood the order of passage of the binary search tree that she was convinced that she had "got it."At that time, I used structure of c to implement it.

In the middle of recursion:
·Display left
·Display yourself
·Display right
Recursively, "Display Left" automatically becomes "Display All Left Elements" (the same goes for the right).Due to the nature of the binary search tree, this is the only ascending display.

ending recursive:
·I myself null

I think this passing order display is a good subject for recursion even though it cannot be easily converted into a loop.

If you can understand mathematical induction, you can understand recursive (in the case of induction, it proves "first").

I interpreted it as a question asking you to tell me the image of the source code of the answer, so I will write a comment on the source code.
Roughly speaking, it is an image that determines how many pieces to put in the kth place, and then the arrangement after that is a round throw after the k+1st place, and outputs when the rest is exactly zero.

//k —The length of the block column.
//res —Number of blocks remaining
//left —Number of blocks stacked in the previous location (=maximum number of blocks stacked in subsequent locations)
// a[ ] —An array containing the current block arrangement, where a[i] contains the stacked height of the i-th place.

void dfs(intk, intres, intleft) {
        if(res<0)return;// If the number of blocks left is less than 0, nothing can be done, so exit
        if(res==0){// If you have used it up perfectly
            // Output the current arrangement
            for(inti=0;i<k-1;i++){
                System.out.print(a[i]+"");
            }
            System.out.println(a[k-1]); // Do not leave spaces at the end, so separate cases
            return;
        }
        // If there are still blocks left that can be used
        for(inti=left;i>=1;i--) {// To the extent that the height limit is not exceeded
            a[k] = i; // kth load i blocks
            dfs(k+1,res-i,i); // k+1 has res-i blocks left and can be loaded to a height of i or less
        }
    }

Is it easy to understand if I write like this?I'm running it on paiza.io.rest means "remaining" and pos means "position".

import java.util.*;

public class Main {

    private inta[]; // How to sort (a1,..., as)

    publicMain(int size){
        a = new int [size+1]; // a0 is dummy; use a1...as
        a[0] = size;
    }

    public void dfs(intrest, intpos) {
        // Displays the current arrangement when the number of squares remaining is zero
        if(rest==0){
            for (inti=1; i<pos-1;i++)
                System.out.print(Integer.toString(a[i])+"";
            System.out.println (Integer.toString(a[pos-1]));
            return;
        }
        // Otherwise, stack the squares to the current position and move them to the right.
        for(inti=Math.min(rest, a[pos-1]);i>=1;i--){
            a[pos] = i;
            dfs(rest-i, pos+1);
        }
    }

    public static void main(String[]args) arrows Exception {
        // Your code here!

        (new Main(5)).dfs(5,1);
    }
}