Given two integer N and K, the task is to find the size of the smallest string that contains all permutations of length N that can be formed using first D digits (0, 1, …, D-1).
Examples:
Input: N = 2, D = 2
Output: 01100
Explanation:
Possible permutations of length 2 from digits (0, 1) are {00, 01, 10, 11}.
“01100” is one such string that contains all the permutations as a substring.
Other possible answers are “00110”, “10011”, “11001”Input: N = 2, D = 4
Output: 03322312113020100
Explaination:
Here all possible permutations of length 2 from digits {0, 1, 2, 3} are
00 10 20 30
01 11 21 31
02 12 22 32
03 13 23 33
“03322312113020100” is a string of minimum length that contains all the above permutations.
Approach:
Append ‘0’ N-1 times and call DFS on the string in the current state. Append all the D characters one by one. Every time after appending, check if the new string is visited or not. If so, mark it visited by inserting it into a HashSet and add this character in the answer. Recursively call the DFS function on the last D characters. Repeat this process until all possible substrings of N length from the D digits are appended to the string. Print the final string generated.
Below is the implementation of the above approach:
Java
// Java Program to find the // minimum length string // consisting of all // permutations of length N // of D digits import java.io.*; import java.util.*; import java.lang.*; class GeeksforGeeks { // Initialize hashset to see // if all the possible // permutations are present // in the min length string static Set<String> visited; // To keep min length string static StringBuilder ans; public static String reqString(int N, int D) { // Base case if (N == 1 && D == 1) return "0"; visited = new HashSet<>(); ans = new StringBuilder(); StringBuilder sb = new StringBuilder(); // Append '0' n-1 times for (int i = 0; i < N - 1; ++i) { sb.append("0"); } String start = sb.toString(); // Call the DFS Function dfs(start, D); ans.append(start); return new String(ans); } // Generate the required string public static void dfs(String curr, int D) { // Iterate over all the possible // character for (int x = 0; x < D; ++x) { // Append to make a new string String neighbour = curr + x; // If the new string is not // visited if (!visited.contains(neighbour)) { // Add in hashset visited.add(neighbour); // Call the dfs function on // the last d characters dfs(neighbour.substring(1), D); ans.append(x); } } } // Driver Code public static void main(String args[]) { int N = 2; int D = 2; System.out.println(reqString(N, D)); } } |
01100
Time Complexity: O(N * DN)
Auxiliary Space: O(N * DN)
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.
