Count of subarrays which forms a permutation from given Array elements

Given an array A[] consisting of integers [1, N], the task is to count the total number of subarrays of all possible lengths x (1 ? x ? N), consisting of a permutation of integers [1, x] from the given array. 

Examples:  

Input: A[] = {3, 1, 2, 5, 4}  Output: 4 
Explanation: 
Subarrays forming a permutation are {1}, {1, 2}, {3, 1, 2} and {3, 1, 2, 5, 4}.
 

Input: A[] = {4, 5, 1, 3, 2, 6} Output: 4 
Explanation: 
Subarrays forming a permutation are {1}, {1, 3, 2}, {4, 5, 1, 3, 2} and {4, 5, 1, 3, 2, 6}.  

Naive Approach: 
Follow the steps below to solve the problem:  

• The simplest approach to solve the problem is to generate all possible subarrays.
• For each subarray, check if it is a permutation of elements in the range [1, length of subarray].
• For every such subarray found, increase count. Finally, print the count.

Time Complexity: O(N³) 
Auxiliary Space: O(1)

Efficient Approach: 
To optimize the above approach, follow the steps below:  

• For every element from i = [1, N], check the maximum and minimum index, at which the elements of the permutation [1, i] are present.
• If the difference between the maximum and minimum index is equal to i, then it means there is a valid contiguous permutation for i.
• For every such permutation, increase the count. Finally, print the count.

Below is the implementation of the above approach: 

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

// Function returns the required count
int PermuteTheArray(int A[], int n)
{

    int arr[n];

    // Store the indices of the
    // elements present in A[].
    for (int i = 0; i < n; i++) {
        arr[A[i] - 1] = i;
    }

    // Store the maximum and
    // minimum index of the
    // elements from 1 to i.
    int mini = n, maxi = 0;
    int count = 0;

    for (int i = 0; i < n; i++) {

        // Update maxi and mini, to
        // store minimum and maximum
        // index for permutation
        // of elements from 1 to i+1
        mini = min(mini, arr[i]);
        maxi = max(maxi, arr[i]);

        // If difference between maxi
        // and mini is equal to i
        if (maxi - mini == i)

            // Increase count
            count++;
    }

    // Return final count
    return count;
}

// Driver Code
int main()
{

    int A[] = { 4, 5, 1, 3, 2, 6 };
    cout << PermuteTheArray(A, 6);

    return 0;
}

// Java program to implement
// the above approach
class GFG{

// Function returns the required count
static int PermuteTheArray(int A[], int n)
{
    int []arr = new int[n];

    // Store the indices of the
    // elements present in A[].
    for(int i = 0; i < n; i++) 
    {
        arr[A[i] - 1] = i;
    }

    // Store the maximum and
    // minimum index of the
    // elements from 1 to i.
    int mini = n, maxi = 0;
    int count = 0;

    for(int i = 0; i < n; i++)
    {

        // Update maxi and mini, to
        // store minimum and maximum
        // index for permutation
        // of elements from 1 to i+1
        mini = Math.min(mini, arr[i]);
        maxi = Math.max(maxi, arr[i]);

        // If difference between maxi
        // and mini is equal to i
        if (maxi - mini == i)

            // Increase count
            count++;
    }

    // Return final count
    return count;
}

// Driver Code
public static void main(String[] args)
{
    int A[] = { 4, 5, 1, 3, 2, 6 };
    
    System.out.print(PermuteTheArray(A, 6));
}
}

// This code is contributed by gauravrajput1 

# Python3 program to implement
# the above approach

# Function returns the required count
def PermuteTheArray(A, n):

    arr = [0] * n

    # Store the indices of the
    # elements present in A[].
    for i in range(n):
        arr[A[i] - 1] = i

    # Store the maximum and
    # minimum index of the
    # elements from 1 to i.
    mini = n
    maxi = 0
    count = 0

    for i in range(n):

        # Update maxi and mini, to
        # store minimum and maximum
        # index for permutation
        # of elements from 1 to i+1
        mini = min(mini, arr[i])
        maxi = max(maxi, arr[i])

        # If difference between maxi
        # and mini is equal to i
        if (maxi - mini == i):

            # Increase count
            count += 1

    # Return final count
    return count

# Driver Code
if __name__ == "__main__":

    A = [ 4, 5, 1, 3, 2, 6 ]
    
    print(PermuteTheArray(A, 6))

# This code is contributed by chitranayal

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

class GFG{

// Function returns the required count
static int PermuteTheArray(int []A, int n)
{
    int []arr = new int[n];

    // Store the indices of the
    // elements present in []A.
    for(int i = 0; i < n; i++) 
    {
        arr[A[i] - 1] = i;
    }

    // Store the maximum and
    // minimum index of the
    // elements from 1 to i.
    int mini = n, maxi = 0;
    int count = 0;

    for(int i = 0; i < n; i++)
    {

        // Update maxi and mini, to
        // store minimum and maximum
        // index for permutation
        // of elements from 1 to i+1
        mini = Math.Min(mini, arr[i]);
        maxi = Math.Max(maxi, arr[i]);

        // If difference between maxi
        // and mini is equal to i
        if (maxi - mini == i)

            // Increase count
            count++;
    }

    // Return final count
    return count;
}

// Driver Code
public static void Main(String[] args)
{
    int []A = { 4, 5, 1, 3, 2, 6 };
    
    Console.Write(PermuteTheArray(A, 6));
}
}

// This code is contributed by gauravrajput1

<script>

// Javascript Program to implement
// the above approach

// Function returns the required count
function PermuteTheArray(A, n)
{

    var arr = Array(n);

    // Store the indices of the
    // elements present in A[].
    for (var i = 0; i < n; i++) {
        arr[A[i] - 1] = i;
    }

    // Store the maximum and
    // minimum index of the
    // elements from 1 to i.
    var mini = n, maxi = 0;
    var count = 0;

    for (var i = 0; i < n; i++) {

        // Update maxi and mini, to
        // store minimum and maximum
        // index for permutation
        // of elements from 1 to i+1
        mini = Math.min(mini, arr[i]);
        maxi = Math.max(maxi, arr[i]);

        // If difference between maxi
        // and mini is equal to i
        if (maxi - mini == i)

            // Increase count
            count++;
    }

    // Return final count
    return count;
}

// Driver Code
var A = [4, 5, 1, 3, 2, 6];
document.write( PermuteTheArray(A, 6));

</script>  

4

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