### Resource constraints

Time limit: 1.0s Memory limit: 256.0MB

### Problem description

Jam is a science freak who likes to be unconventional. Instead of counting with Arabic numerals, he used lowercase English letters. He felt that doing so would make the world more colorful. In his counting method, the number of digits of each number is the same (using the same number of letters). The English letters are in the original order, and the letters in front of them are smaller than those after them. We call such "numbers" jam numbers. In jam numbers, each letter is different from each other and increases strictly from left to right. Each time, jam also specifies the range of letters to use, for example, from 2 to 10, which means that only {b,c,d,e,f,g,h,i,j} can be used. If the number of digits is specified as 5, the number immediately after jam number "bdfij" should be "bdghi". (if we use U and V to represent jam numbers "bdfij" and "bdghi" in turn, then U < V < span >, and there is no jam number P, so that U < p < V < span >). Your task is: for a jam number read from the file, output the next five jam numbers in sequence. If there are not so many jam numbers, output several.

### Input format

There are 2 lines, the first line is 3 positive integers, separated by a space:

s t w

(where s is the serial number of the smallest letter used, t is the serial number of the largest letter used. W is the number of digits, and these three numbers meet: 1 ≤ s < T ≤ 26, 2 ≤ w ≤ t-s)

The second line is a string with w lowercase letters, which is a qualified Jam number.

The data given are correct and do not need to be verified.

### Output format

Up to 5 lines, which are the 5 Jam numbers immediately after the input Jam numbers. If there are not so many Jam numbers, several will be output. Only one Jam number is output on each line, which is a string composed of w lowercase letters without redundant spaces.

### sample input

2 10 5

bdfij

### sample output

bdghi

bdghj

bdgij

bdhij

befgh

### Problem solving ideas:

Select the five digits that increase the dictionary order in turn from the 26 letters, and require the output of the next five sequences. In fact, the restriction condition is added on the basis of full arrangement, that is, the dictionary order needs to be increased, which can reduce the depth of recursion. Just judge whether the dictionary order is larger than the previous letter before adding letters each time. After the starting sequence of jam is given in the recursive finding problem, five sequences can be output in turn.

Full permutation problem:

Total permutation problemhttps://blog.csdn.net/weixin_48898946/article/details/121589155

### java code:

import java.io.*; public class Main { public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String[] split = br.readLine().split(" "); int s = Integer.parseInt(split[0]); int e = Integer.parseInt(split[1]); int len = Integer.parseInt(split[2]); String str = br.readLine(); Temp32 obj = new Temp32(s, e, len, str); obj.dfs(1); } } class Temp32{ int s;//Start subscript int e;//End subscript int len;//Digital length String str;//The jam start sequence given in question int count = 0;//Counter to control the number of outputs boolean flag = false;//Flag jam to start the next item in the sequence char []ch = new char[27];//Store 26 lowercase letters, starting from 1 in the following table boolean []vis = new boolean[27];//Indicates whether a letter has appeared StringBuilder builder = new StringBuilder();//Real time splicing public Temp32(int s, int e, int len, String str) { this.s = s; this.e = e; this.len = len; this.str = str; for(int i = 1; i <= 26; i++) { ch[i] = (char)(96 + i); } } public void dfs(int step) {//The letter to be placed in the step length if(step > len) {//It's full if(count == 0) {//Find the jam start sequence given by the question flag = str.equals(builder.toString());//Found flag is true } if(flag) {//Output 5 times count++; if(count <= 6 && count != 1) { System.out.println(builder); } if(count > 6) { System.exit(0); } } return; } for(int i = s; i <= e; i++) {//From s pendulum to e if(!vis[i]) {//Not visited if(step > 1 && ch[i] <= builder.charAt(step - 2)) { continue;//It is necessary to ensure that the last letter is larger than the previous dictionary } vis[i] = true;//Visited builder.append(ch[i]);//Add to builder dfs(step + 1);//Place next letter vis[i] = false;//to flash back builder.deleteCharAt(builder.length() - 1); } } } }