Related Articles

Related Articles

Count number of permutation of an Array having no SubArray of size two or more from original Array
  • Difficulty Level : Easy
  • Last Updated : 11 Sep, 2019

Given an array of distinct integer A, the task is to count the number of possible permutations of the given array A[] such that the permutations do not contain any subarray of size 2 or more from the original array.

Examples:

Input: A = [ 1, 3, 9 ]
Output: 3
All the permutation of [ 1, 3, 9 ] are : [ 1, 3, 9 ], [ 1, 9, 3 ], [ 3, 9, 1 ], [ 3, 1, 9 ], [ 9, 1, 3 ], [ 9, 3, 1 ]

Here [ 1, 3, 9 ], [ 9, 1, 3 ] are removed as they contain sub-array [ 1, 3 ] from original list
and [ 3, 9, 1 ] removed as it contains sub-array [3, 9] from original list so,
Following are the 3 arrays that satisfy the condition : [1, 9, 3], [3, 1, 9], [9, 3, 1]

Input : A = [1, 3, 9, 12]
Output :11



Naive Approach: Iterate through list of all permutations and remove those arrays which contains any sub-array [ i, i+1 ] from A.

Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python implementation of the approach
  
# Importing the itertools 
from itertools import permutations
  
# Function that return count of all the permutation
# having no sub-array of [ i, i + 1 ]
def count(arr):
    z =[]
    perm = permutations(arr)
    for i in list(perm):
        z.append(list(i))
  
    q =[]
    for i in range(len(arr)-1):
        x, y = arr[i], arr[i + 1]
        for j in range(len(z)):
  
            # Finding the indexes where x is present
            if z[j].index(x)!= len(z[j])-1:
  
                # If y is present at position of x + 1
                # append into a temp list q
                if z[j][z[j].index(x)+1]== y:
                    q.append(z[j])
  
    # Removing all the lists that are present
    # in z ( list of all premutations )
    for i in range(len(q)):
         if q[i] in z:
             z.remove(q[i])
    return len(z)
  
# Driver Code
A =[1, 3, 9]
print(count(A))

chevron_right


Output:

3

Efficient Solution : After making the solution for smaller size of array, we can observe a pattern:

The following pattern generates a recurrence:
Suppose the length of array A is n, then:

count(0) = 1
count(1) = 1
count(n) = n * count(n-1) + (n-1) * count(n-2)

Below is the implementation of the approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach 
#include<bits/stdc++.h>
using namespace std;
  
// Recursive function that returns 
// the count of permutation-based 
// on the length of the array. 
int count(int n)
    if(n == 0)
        return 1;
    if(n == 1)
        return 1;
    else
        return (n * count(n - 1)) + 
              ((n - 1) * count(n - 2));
}
  
// Driver Code
int main()
{
    int A[] = {1, 2, 3, 9};
      
    // length of array
    int n = 4;
          
    // Output required answer
    cout << count(n - 1); 
          
    return 0;
}
  
// This code is contributed by Sanjit Prasad

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach 
import java.util.*;
  
class GFG
{
  
// Recursive function that returns 
// the count of permutation-based 
// on the length of the array. 
static int count(int n)
    if(n == 0)
        return 1;
    if(n == 1)
        return 1;
    else
        return (n * count(n - 1)) + 
              ((n - 1) * count(n - 2));
}
  
// Driver Code
public static void main(String[] args)
{
    int A[] = {1, 2, 3, 9};
      
    // length of array
    int n = 4;
          
    // Output required answer
    System.out.println(count(n - 1)); 
}
  
// This code is contributed by PrinciRaj1992

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python implementation of the approach
  
# Recursive function that returns
# the count of permutation-based
# on the length of the array.
  
def count(n):
    if n == 0:
        return 1
    if n == 1:
        return 1
    else:
        return (n * count(n-1)) + ((n-1) * count(n-2))
  
# Driver Code
A =[1, 2, 3, 9]
print(count(len(A)-1))

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the above approach
using System;
  
class GFG
{
  
// Recursive function that returns 
// the count of permutation-based 
// on the length of the array. 
static int count(int n)
    if(n == 0)
        return 1;
    if(n == 1)
        return 1;
    else
        return (n * count(n - 1)) + 
              ((n - 1) * count(n - 2));
}
  
// Driver Code
public static void Main(String[] args)
{
    int []A = {1, 2, 3, 9};
      
    // length of array
    int n = 4;
          
    // Output required answer
    Console.WriteLine(count(n - 1)); 
}
}
  
// This code is contributed by PrinciRaj1992

chevron_right


Output:

11

Note: For the above recurrence you can check oeis.org.

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
Recommended Articles
Page :