 Open in App
Not now

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

• Difficulty Level : Expert
• Last Updated : 02 Jun, 2021

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 ``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(Setarr,``                           ``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 arr = ``new` `HashSet();``    ` `    ``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

 ``

Output:

`10`

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

My Personal Notes arrow_drop_up