Length of smallest Subarray with at least one element repeated K times

Given an array arr[] of length N and an integer K. The task is to find the minimum length of subarray such that at least one element of the subarray is repeated exactly K times in that subarray. If no such subarray exists, print -1.

Examples:

Input: arr[] = {1, 2, 1, 2, 1}, K = 2
Output: 3
Explanation:  Subarray [1,2,1], have K = 2 occurrences of 1

Input: arr[] = {2, 2, 2, 3, 4}, K = 3
Output: 3

Brute Force/Naive Approach: Brute force approach is to iterate over all possible subarrays of the array, and for each subarray, count the occurrence of each element. If an element occurs exactly K times, then the length of the subarray is a candidate for the minimum length subarray.

1. Initialize a variable mn to INT_MAX, which will store the minimum length subarray.
2. Loop through each starting index i in the array, from 0 to N-1.
   • Initialize a variable count to 0, which will count the occurrence of the element arr[i].
   • Loop through each ending index j in the array, from i to N-1.
     • If the current element arr[j] is the same as arr[i], increment the count.
     • If the count is equal to K, update mn to the minimum value between mn and j-i+1 (the length of the current subarray).
     • Continue looping until all subarrays with starting index i have been checked.
3. After looping through all starting indices, if mn is still equal to INT_MAX, there is no subarray with an element occurring exactly K times. Return -1.
4. Otherwise, return mn as the length of the minimum length subarray with an element occurring exactly K times.

Below is the implementation of the above approach:

#include <bits/stdc++.h>
using namespace std;

// Function to return the minimum length of
// subarray having an element exactly K times
int minLengthKRepetitions(int* arr, int& N, int& K)
{
    int mn = INT_MAX;
    for (int i = 0; i < N; i++) {
        int count = 0;
        for (int j = i; j < N; j++) {
            if (arr[j] == arr[i]) {
                count++;
            }
            if (count == K) {
                mn = min(mn, j - i + 1);
                break;
            }
        }
    }

    return (mn == INT_MAX) ? -1 : mn;
}

// Driver code
int main()
{
    int arr[] = { 1, 2, 2, 2, 1 };
    int N = sizeof(arr) / sizeof(arr[0]);
    int K = 3;
     
    cout << minLengthKRepetitions(arr, N, K);
    return 0;
}

import java.util.*;

public class Main {

  // Function to return the minimum length of
  // subarray having an element exactly K times
  public static int minLengthKRepetitions(int[] arr, int N, int K) {
    int mn = Integer.MAX_VALUE;
    for (int i = 0; i < N; i++) {
      int count = 0;
      for (int j = i; j < N; j++) {
        if (arr[j] == arr[i]) {
          count++;
        }
        if (count == K) {
          mn = Math.min(mn, j - i + 1);
          break;
        }
      }
    }
    return (mn == Integer.MAX_VALUE) ? -1 : mn;
  }

  // Driver code
  public static void main(String[] args) {
    int[] arr = { 1, 2, 2, 2, 1 };
    int N = arr.length;
    int K = 3;
    System.out.println(minLengthKRepetitions(arr, N, K));
  }
}

// This code is cntributed by shivregkec

import sys

# Function to return the minimum length of
# subarray having an element exactly K times
def minLengthKRepetitions(arr, N, K):
    mn = sys.maxsize
    for i in range(N):
        count = 0
        for j in range(i, N):
            if arr[j] == arr[i]:
                count += 1
            if count == K:
                mn = min(mn, j - i + 1)
                break
    return -1 if mn == sys.maxsize else mn

# Driver code
arr = [1, 2, 2, 2, 1]
N = len(arr)
K = 3
print(minLengthKRepetitions(arr, N, K))

# This code is contributed by shivhack999

using System;

public class MainClass {
    // Function to return the minimum length of
    // subarray having an element exactly K times
    public static int
    MinLengthKRepetitions(int[] arr, ref int N, ref int K)
    {
        int mn = int.MaxValue;
        for (int i = 0; i < N; i++) {
            int count = 0;
            for (int j = i; j < N; j++) {
                if (arr[j] == arr[i]) {
                    count++;
                }
                if (count == K) {
                    mn = Math.Min(mn, j - i + 1);
                    break;
                }
            }
        }

        return (mn == int.MaxValue) ? -1 : mn;
    }

    // Driver code
    public static void Main()
    {
        int[] arr = { 1, 2, 2, 2, 1 };
        int N = arr.Length;
        int K = 3;

        Console.WriteLine(
            MinLengthKRepetitions(arr, ref N, ref K));
    }
}
// This code is contributed by user_dtewbxkn77n

// Function to return the minimum length of
// subarray having an element exactly K times
function minLengthKRepetitions(arr, K) {
    let mn = Number.MAX_VALUE;
    const N = arr.length;

    for (let i = 0; i < N; i++) {
        let count = 0;
        for (let j = i; j < N; j++) {
            if (arr[j] === arr[i]) {
                count++;
            }
            if (count === K) {
                mn = Math.min(mn, j - i + 1);
                break;
            }
        }
    }

    return mn === Number.MAX_VALUE ? -1 : mn;
}

// Driver code
const arr = [1, 2, 2, 2, 1];
const K = 3;

console.log(minLengthKRepetitions(arr, K));

Output:

3

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

Efficient Approach: In this problem, observe that the smallest length will be achieved when we have exactly one element in the subarray which has K frequency which means subarray will look something like [X . . . X] where X is an element of array arr. Now, follow the steps below to solve this problem:

1. Create an array of pairs, such that the number (i.e. arr[i]) is the first element and its index (i.e. i) is second.
2. Sort this array.
3. Now, create a variable mn to store the answer and initialize it with INT_MAX.
4. Now, traverse the array from i = 0 to i = (N - K) and in each iteration:
   • If the element at i and (i+K-1) is equal then make mn equal to the minimum out of mn and the difference between the indexes of the following.
5. Return mn as the final answer.

Below is the implementation of the above approach:

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to return the minimum length of
// subarray having an element exactly K times
int minLengthKRepetitions(int* arr, int& N, 
                          int& K)
{
    pair<int, int> indices[N];
    int mn = INT_MAX, i;

    for (i = 0; i < N; i++) {
        indices[i].first = arr[i];
        indices[i].second = i;
    }

    sort(indices, indices + N);
    for (i = 0; i <= N - K; i++) {
        if (indices[i].first == indices[i + K - 1].first)
            mn = min(mn, indices[i + K - 1].second
                             - indices[i].second + 1);
    }

    return (mn == INT_MAX) ? -1 : mn;
}

// Driver code
int main()
{
    int arr[] = { 1, 2, 2, 2, 1 };
    int N = sizeof(arr) / sizeof(arr[0]);
    int K = 3;
    
    cout << minLengthKRepetitions(arr, N, K);
    return 0;
}

// Java code to implement the above approach
import java.util.*;

class GFG {

  // Function to return the minimum length of
  // subarray having an element exactly K times
  public static int minLengthKRepetitions(int[] arr, int N, int K)
  {
    int[][] indices = new int[N][2] ;
    int mn = Integer.MAX_VALUE, i;

    for (i = 0; i < N; i++) {
      indices[i][0] = arr[i];
      indices[i][1] = i;
    }

    //Arrays.sort(indices);
    for (i = 0; i <= N - K; i++) {
      if (indices[i][0] == indices[i + K - 1][0])
        mn = Math.min(mn, indices[i + K - 1][1]
                      - indices[i][1] + 1);
    }

    return (mn == Integer.MAX_VALUE) ? -1 : mn;
  }

  // Driver code
  public static void main (String[] args)
  {
    int[] arr = { 1, 2, 2, 2, 1 };
    int N = arr.length;
    int K = 3;

    System.out.println(minLengthKRepetitions(arr, N, K));
  }
}

// This code is contributed by Shubham Singh

# Python program for the above approach

# Function to return the minimum length of
# subarray having an element exactly K times
def minLengthKRepetitions(arr, N, K):
    
    indices = [[0,0] for i in range(N)]
    mn = 2**32
    
    for i in range(N):
        indices[i][0] = arr[i]
        indices[i][1] = i
    
    indices.sort()
    for i in range(N - K + 1):
        if (indices[i][0] == indices[i + K - 1][0]):
            mn = min(mn, indices[i + K - 1][1] - indices[i][1] + 1)
            
    return -1 if(mn == 2**32) else mn

# Driver code
arr = [1, 2, 2, 2, 1]
N = len(arr)
K = 3

print(minLengthKRepetitions(arr, N, K))

# This code is contributed by Shubham Singh

// C# code to implement the above approach
using System;
public class GFG
{

  // Function to return the minimum length of
  // subarray having an element exactly K times
  public static int minLengthKRepetitions(int[] arr, int N, int K)
  {
    int[,] indices = new int[N,2] ;
    int mn = Int32.MaxValue, i;

    for (i = 0; i < N; i++) {
      indices[i, 0] = arr[i];
      indices[i, 1] = i;
    }

    //Arrays.sort(indices);
    for (i = 0; i <= N - K; i++) {
      if (indices[i,0] == indices[i + K - 1,0])
        mn = Math.Min(mn, indices[i + K - 1,1]
                      - indices[i,1] + 1);
    }

    return (mn == Int32.MaxValue) ? -1 : mn;
  }

  // Driver code
  static public void Main ()
  {
    int[] arr = { 1, 2, 2, 2, 1 };
    int N = arr.Length;
    int K = 3;

    Console.Write(minLengthKRepetitions(arr, N, K));
  }
}

// This code is contributed by Shubham Singh

 <script>
        // JavaScript code for the above approach


        // Function to return the minimum length of
        // subarray having an element exactly K times
        function minLengthKRepetitions(arr, N,
            K) {
            let indices = [];
            let mn = Number.MAX_VALUE, i;

            for (i = 0; i < N; i++) {
                indices.push({ first: arr[i], second: i })
            }

            indices.sort(function (a, b) { return a.first - b.first; });
            for (i = 0; i <= N - K; i++) {
                if (indices[i].first == indices[i + K - 1].first)
                    mn = Math.min(mn, indices[i + K - 1].second
                        - indices[i].second + 1);
            }

            return (mn == Number.MAX_VALUE) ? -1 : mn;
        }

        // Driver code

        let arr = [1, 2, 2, 2, 1];
        let N = arr.length;
        let K = 3;

        document.write(minLengthKRepetitions(arr, N, K));

  // This code is contributed by Potta Lokesh
    </script>

3

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

prophet1999

Follow

Improve

Article Tags :

• Greedy
• Mathematical
• Competitive Programming
• TrueGeek
• Algo Geek
• DSA
• Arrays
• Algo-Geek 2021
• subarray

+5 More

Practice Tags :

• Arrays
• Greedy
• Mathematical