Count of permutations of an Array having each element as a multiple or a factor of its index

Given an integer, N, the task is to count the number of ways to generate an array, arr[] of consisting of N integers such that for every index i(1-based indexing), arr[i] is either a factor or a multiple of i, or both. The arr[] must be the permutations of all the numbers from the range [1, N].

Examples:

Input: N=2
Output: 2
Explanation:
Two possible arrangements are {1, 2} and {2, 1}

Input: N=3
Output: 3
Explanation:
The 6 possible arrangements are {1, 2, 3}, {2, 1, 3}, {3, 2, 1}, {3, 1, 2}, {2, 3, 1} and {1, 3, 2}.
Among them, the valid arrangements are {1, 2, 3}, {2, 1, 3} and {3, 2, 1}.

Approach: The problem can be solved using Backtracking technique and the concept of print all permutations using recursion. Follow the steps below to find the recurrence relation:

1. Traverse the range [1, N].
2. For the current index pos, if i % pos == 0 and i % pos == 0, then insert i into the arrangement and use the concept of Backtracking to find valid permutations.
3. Remove i.
4. Repeat the above steps for all values in the range [1, N], and finally, print the count of valid permutations.

Below is the implementation of the above approach:

C++

// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find the count of
// desired permutations
int findPermutation(unordered_set<int>& arr,
                    int N)
{
    int pos = arr.size() + 1;

    // Base case
    if (pos > N)
        return 1;

    int res = 0;

    for (int i = 1; i <= N; i++) {

        // If i has not been inserted
        if (arr.find(i) == arr.end()) {

            // Backtrack
            if (i % pos == 0 or pos % i == 0) {

                // Insert i
                arr.insert(i);

                // Recur to find valid permutations
                res += findPermutation(arr, N);

                // Remove i
                arr.erase(arr.find(i));
            }
        }
    }

    // Return the final count
    return res;
}

// Driver Code
int main()
{
    int N = 5;
    unordered_set<int> arr;
    cout << findPermutation(arr, N);

    return 0;
}

Java

// Java program to implement
// the above approach
import java.util.*;

class GFG{

// Function to find the count of
// desired permutations
static int findPermutation(Set<Integer>arr,
                           int N)
{
    int pos = arr.size() + 1;

    // Base case
    if (pos > N)
        return 1;

    int res = 0;

    for(int i = 1; i <= N; i++)
    {

        // If i has not been inserted
        if (! arr.contains(i))
        {

            // Backtrack
            if (i % pos == 0 || pos % i == 0)
            {

                // Insert i
                arr.add(i);

                // Recur to find valid permutations
                res += findPermutation(arr, N);

                // Remove i
                arr.remove(i);
            }
        }
    }

    // Return the final count
    return res;
}

// Driver Code
public static void main(String []args)
{
    int N = 5;
    Set<Integer> arr = new HashSet<Integer>();

    System.out.print(findPermutation(arr, N));
}
}

// This code is contributed by chitranayal

Python3

# Python3 program to implement
# the above approach

# Function to find the count of
# desired permutations
def findPermutation(arr, N):

    pos = len(arr) + 1

    # Base case
    if(pos > N):
        return 1

    res = 0

    for i in range(1, N + 1):

        # If i has not been inserted
        if(i not in arr):

            # Backtrack
            if(i % pos == 0 or pos % i == 0):

                # Insert i
                arr.add(i)

                # Recur to find valid permutations
                res += findPermutation(arr, N)

                # Remove i
                arr.remove(i)

    # Return the final count
    return res

# Driver Code
N = 5
arr = set()

# Function call
print(findPermutation(arr, N))

# This code is contributed by Shivam Singh

C#

// C# program to implement
// the above approach
using System;
using System.Collections.Generic;

class GFG{

// Function to find the count of
// desired permutations
static int findPermutation(HashSet<int>arr,
                           int N)
{
    int pos = arr.Count + 1;

    // Base case
    if (pos > N)
        return 1;

    int res = 0;

    for(int i = 1; i <= N; i++)
    {

        // If i has not been inserted
        if (! arr.Contains(i))
        {

            // Backtrack
            if (i % pos == 0 || pos % i == 0)
            {

                // Insert i
                arr.Add(i);

                // Recur to find valid permutations
                res += findPermutation(arr, N);

                // Remove i
                arr.Remove(i);
            }
        }
    }

    // Return the readonly count
    return res;
}

// Driver Code
public static void Main(String []args)
{
    int N = 5;
    HashSet<int> arr = new HashSet<int>();

    Console.Write(findPermutation(arr, N));
}
}

// This code is contributed by gauravrajput1

Javascript

<script>

// Javascript program to implement
// the above approach

// Function to find the count of
// desired permutations
function findPermutation(arr, N)
{
    var pos = arr.size + 1;

    // Base case
    if (pos > N)
        return 1;

    var res = 0;

    for(var i = 1; i <= N; i++)
    {

        // If i has not been inserted
        if (!arr.has(i))
        {

            // Backtrack
            if (i % pos == 0 || pos % i == 0)
            {

                // Insert i
                arr.add(i);

                // Recur to find valid permutations
                res += findPermutation(arr, N);

                // Remove i
                arr.delete(i);
            }
        }
    }

    // Return the final count
    return res;
}

// Driver Code
var N = 5;
var arr = new Set();

document.write(findPermutation(arr, N));

// This code is contributed by importantly

</script>

Output:

10

Time Complexity: O(N×N!)
Auxiliary Space: O(N)