Open In App

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

Last Updated : 11 Mar, 2024
Improve
Improve
Like Article
Like
Save
Share
Report

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


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>


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


Output

10

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

Using Brute Force in python:

Approach:

The first approach is to generate all possible permutations of the array and check if each element is a multiple or a factor of its index. We can do this using a recursive function to generate permutations and then checking each permutation.

  • Define a function is_valid(arr) that takes an array arr and checks if each element is a multiple or a factor of its index. It returns True if all elements satisfy this condition, otherwise False.
  • Define a recursive function generate_permutations(arr, l, r, valid_permutations) that generates all possible permutations of the array arr from index l to index r. For each permutation, it checks if it is valid using the function is_valid(arr). If a valid permutation is found, it is added to the list valid_permutations.
  • Define a function count_permutations(n) that creates an array arr of size n, initializes it with values 1 to n, and calls the function generate_permutations() with arr, 0, n-1, and an empty list valid_permutations. It then returns the length of valid_permutations.
    Call the function count_permutations() with the input n and print the result.

Python3




def is_valid(arr):
    for i in range(len(arr)):
        if arr[i] % (i+1) != 0 and (i+1) % arr[i] != 0:
            return False
    return True
 
def generate_permutations(arr, l, r, valid_permutations):
    if l == r:
        if is_valid(arr):
            valid_permutations.append(arr[:])
    else:
        for i in range(l, r+1):
            arr[l], arr[i] = arr[i], arr[l]
            generate_permutations(arr, l+1, r, valid_permutations)
            arr[l], arr[i] = arr[i], arr[l]
 
def count_permutations(n):
    arr = [i+1 for i in range(n)]
    valid_permutations = []
    generate_permutations(arr, 0, n-1, valid_permutations)
    return len(valid_permutations)
 
print(count_permutations(2)) # Output: 2
print(count_permutations(3)) # Output: 3


Output

2
3

Time Complexity: O(n!)
Space Complexity: O(n!)

Python Solution (Dynamic Programming):

Approach:

  1. Initialize a 2D array dp to store the count of permutations. Each cell dp[i][j] represents the count of permutations with i elements and j numbers selected.
  2. Initialize the base case dp[0][0] = 1.
  3. Fill the dp array using dynamic programming. Iterate over the range [1, N] for the number of elements and [0, N] for the selected numbers.
  4. For each element i, iterate over the range [1, min(i, j)] to represent selecting each number up to i or j, whichever is smaller.
  5. Increment dp[i][j] by dp[i – 1][j – k] for permutations including the current number i, where k represents the selected number.
  6. Increment dp[i][j] by dp[i – 1][j] for permutations excluding the current number i.
  7. Sum up the counts of all valid permutations stored in dp[N].
  8. Return the count of valid permutations.

Python3




def countPermutations(N):
    # Initialize a 2D array to store the count of permutations
    dp = [[0] * (N + 1) for _ in range(N + 1)]
     
    # Initialize the base case
    dp[0][0] = 1
     
    # Fill the dp array using dynamic programming
    for i in range(1, N + 1):
        for j in range(N + 1):
            for k in range(1, i + 1):
                if i % k == 0 or k % i == 0:
                    dp[i][j] += dp[i - 1][j - 1]
     
    # Sum up the counts of all valid permutations
    count = sum(dp[N][1:])
     
    return count
 
# Test cases
print(countPermutations(2))  # Output: 2


Output

2

Time Complexity: O(n^3)

Space Complexity: O(n^2)



Like Article
Suggest improvement
Previous
Next
Share your thoughts in the comments

Similar Reads