Count of subarrays of size K which is a permutation of numbers from 1 to K

Given an array arr of distinct integers, the task is to find count of sub-arrays of size i having all elements from 1 to i, in other words the sub-array is any permutation of elements from 1 to i, with 1 < = i <= N.
Examples: 
 

Input: arr[] = {2, 3, 1, 5, 4} 
Output:
Explanation: 
we have {1}, {2, 3, 1} and {2, 3, 1, 5, 4} subarray for i=1, i=3, i=5 respectively. 
Permutation of size 4 and size 2 can’t be made because 5 and 3 are in the way respectively.
Input: arr[] = {1, 3, 5, 4, 2} 
Output:
Explanation: 
we have {1} and {1, 3, 5, 4, 2} subarray for i=1 and i=5 respectively. 
 

 

A Naive approach is to start from each index and try to find subarray of every size(i) and check whether all elements from 1 to i are present. 
Time complexity: O(N2)
An Efficient approach can be given by checking if it is possible to create a subarray of size i for every value of i from 1 to N.
As we know every subarray of size K must be a permutation of all elements from 1 to K, knowing that we can look at the index of the numbers from 1 to N in order and calculate the index of the minimum and maximum value at every step. 
 

  • If maximum_ind – minimum_ind + 1 = K, then we have a permutation of size K, else not. 
     
  • Update the value of minimum_ind and maximum_ind at every step.

Time complexity: O(n)
Illustration: 
 



Given Arr = {2, 3, 1, 5, 4}, let’s start with min_ind = INF and max_ind = -1 
 

  1. index of 1 is 2, so min_ind = min(min_ind, 2) = 2 and max_ind = max(max_ind, 2) = 2, 
    2-2+1 = 1 so we have a permutation of size 1
  2. index of 2 is 0, so min_ind = min(min_ind, 0) = 0 and max_ind = max(max_ind, 0) = 2, 
    2-0+1 = 3 so we don’t have a permutation of size 2
  3. index of 3 is 1, so min_ind = min(min_ind, 1) = 0 and max_ind = max(max_ind, 1) = 2, 
    2-0+1 = 3 so we have a permutation of size 3
  4. index of 4 is 4, so min_ind = min(min_ind, 4) = 0 and max_ind = max(max_ind, 4) = 4, 
    4-0+1 = 5 so we don’t have a permutation of size 4
  5. index of 5 is 3, so min_ind = min(min_ind, 3) = 0 and max_ind = max(max_ind, 4) = 4, 
    4-0+1 = 5 so we have a permutation of size 5 
     

So answer is 3 
 

Below is implementation of the above approach:
 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to implement
// the above approach
  
#include <iostream>
#include <unordered_map>
#include <vector>
using namespace std;
  
int find_permutations(vector<int>& arr)
{
    int cnt = 0;
    int max_ind = -1, min_ind = 10000000;
    int n = arr.size();
    unordered_map<int, int> index_of;
  
    // Save index of numbers of the array
    for (int i = 0; i < n; i++) {
        index_of[arr[i]] = i + 1;
    }
  
    for (int i = 1; i <= n; i++) {
  
        // Update min and max index
        // with the current index
        // and check if it's a valid permutation
        max_ind = max(max_ind, index_of[i]);
        min_ind = min(min_ind, index_of[i]);
        if (max_ind - min_ind + 1 == i)
            cnt++;
    }
  
    return cnt;
}
  
// Driver code
int main()
{
    vector<int> nums;
    nums.push_back(2);
    nums.push_back(3);
    nums.push_back(1);
    nums.push_back(5);
    nums.push_back(4);
  
    cout << find_permutations(nums);
  
    return 0;
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to implement
# the above approach
def find_permutations(arr):
      
    cnt = 0
    max_ind = -1
    min_ind = 10000000;
      
    n = len(arr)
    index_of = {}
  
    # Save index of numbers of the array
    for i in range(n):
        index_of[arr[i]] = i + 1
  
    for i in range(1, n + 1):
  
        # Update min and max index with the
        # current index and check if it's a
        # valid permutation
        max_ind = max(max_ind, index_of[i])
        min_ind = min(min_ind, index_of[i])
          
        if (max_ind - min_ind + 1 == i):
            cnt += 1
              
    return cnt
  
# Driver code
if __name__ == "__main__":
  
    nums = []
    nums.append(2)
    nums.append(3)
    nums.append(1)
    nums.append(5)
    nums.append(4)
  
    print(find_permutations(nums))
  
# This code is contributed by chitranayal

chevron_right


Output: 

3

 

competitive-programming-img




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : jesuswahrman, chitranayal