Smallest number containing all possible N length permutations using digits 0 to D

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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));
    }
}

chevron_right


Output:

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.




My Personal Notes arrow_drop_up

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.