Smallest element present in every subarray of all possible lengths

// Java program for the above approach
import java.util.*;
import java.lang.*;

class GFG
{

  // Function to add count of numbers
  // in the map for a subarray of length k
  static void uniqueElements(int arr[], int start, int K,
                             Map<Integer,Integer> mp)
  {
    // Set to store unique elements
    Set<Integer> st=new HashSet<>();

    // Add elements to the set
    for (int i = 0; i < K; i++)
      st.add(arr[start + i]);

    // Iterator of the set
    Iterator itr = st.iterator();

    // Adding count in map
    while(itr.hasNext())
    {
      Integer t = (Integer)itr.next();
      mp.put(t,mp.getOrDefault(t, 0) + 1);
    }

  }

  // Function to check if there is any number
  // which repeats itself in every subarray
  // of length K
  static void checkAnswer(Map<Integer,Integer> mp, int N, int K)
  {

    // Check all number starting from 1
    for (int i = 1; i <= N; i++) 
    {

      // Check if i occurred n-k+1 times
      if(mp.containsKey(i))    
        if (mp.get(i) == (N - K + 1))
        {

          // Print the smallest number
          System.out.print(i + " ");
          return;
        }
    }

    // Print -1, if no such number found
    System.out.print(-1 + " ");
  }

  // Function to count frequency of each
  // number in each subarray of length K
  static void smallestPresentNumber(int arr[], int N, int K)
  {
    Map<Integer, Integer> mp = new HashMap<>();

    // Traverse all subarrays of length K
    for (int i = 0; i <= N - K; i++) 
    {
      uniqueElements(arr, i, K, mp);
    }

    // Check and print the smallest number
    // present in every subarray and print it
    checkAnswer(mp, N, K);
  }

  // Function to generate the value of K
  static void generateK(int arr[], int N)
  {
    for (int k = 1; k <= N; k++)

      // Function call
      smallestPresentNumber(arr, N, k);
  }

  // Driver code
  public static void main (String[] args) 
  {
    // Given array
    int arr[] = { 2, 3, 5, 3, 2, 3, 1, 3, 2, 7 };

    // Size of array
    int N = arr.length;

    // Function call
    generateK(arr, N);

  }
}

// This code is contributed by offbeat.

// Java program for above approach
import java.util.*;
import java.lang.*;

class GFG
{

  // Function to print the common
  // elements for all subarray lengths
  static void printAnswer(int answer[], int N)
  {
    for (int i = 1; i <= N; i++)
    {
      System.out.print(answer[i]+" ");
    }
  }

  // Function to find and store the
  // minimum element present in all
  // subarrays of all lengths from 1 to n
  static void updateAnswerArray(int answer[], int N)
  {
    int i = 0;

    // Skip lengths for which
    // answer[i] is -1
    while (answer[i] == -1)
      i++;

    // Initialize minimum as the first
    // element where answer[i] is not -1
    int minimum = answer[i];

    // Updating the answer array
    while (i <= N) {

      // If answer[i] is -1, then minimum
      // can be substituted in that place
      if (answer[i] == -1)
        answer[i] = minimum;

      // Find minimum answer
      else
        answer[i] = Math.min(minimum, answer[i]);
      minimum = Math.min(minimum, answer[i]);
      i++;
    }
  }

  // Function to find the minimum number
  // corresponding to every subarray of
  // length K, for every K from 1 to N
  static void lengthOfSubarray(ArrayList<ArrayList<Integer>> indices,
                               Set<Integer> st, int N)
  {
    // Stores the minimum common
    // elements for all subarray lengths
    int[] answer = new int[N + 1];

    // Initialize with -1.
    Arrays.fill(answer, -1);

    // Find for every element, the minimum length
    // such that the number is present in every
    // subsequence of that particular length or more
    Iterator itr = st.iterator();
    while (itr.hasNext()) 
    {

      // To store first occurrence and
      // gaps between occurrences
      int start = -1;
      int gap = -1;
      int t = (int)itr.next();

      // To cover the distance between last
      // occurrence and the end of the array
      indices.get(t).add(N);

      // To find the distance
      // between any two occurrences
      for (int i = 0; i < indices.get(t).size(); i++)
      {
        gap = Math.max(gap, indices.get(t).get(i) - start);
        start = indices.get(t).get(i);
      }
      if (answer[gap] == -1)
        answer[gap] = t;
    }

    // Update and store the answer
    updateAnswerArray(answer, N);

    // Print the required answer
    printAnswer(answer, N);
  }

  // Function to find the smallest
  // element common in all subarrays for
  // every possible subarray lengths
  static void smallestPresentNumber(int arr[], int N)
  {
    // Initializing indices array
    ArrayList<ArrayList<Integer>> indices = new ArrayList<>();

    for(int i = 0; i <= N; i++)
      indices.add(new ArrayList<Integer>());

    // Store the numbers present
    // in the array
    Set<Integer> elements = new HashSet<>();

    // Push the index in the indices[A[i]] and
    // also store the numbers in set to get
    // the numbers present in input array
    for (int i = 0; i < N; i++) 
    {
      indices.get(arr[i]).add(i);
      elements.add(arr[i]);
    }

    // Function call to calculate length of
    // subarray for which a number is present
    // in every subarray of that length
    lengthOfSubarray(indices, elements, N);
  }

  // Driver function
  public static void main (String[] args)
  {

    // Given array
    int arr[] = { 2, 3, 5, 3, 2, 3, 1, 3, 2, 7 };

    // Size of array
    int N = arr.length;

    // Function Call
    smallestPresentNumber(arr, N);
  }
}

// This code is contributed by offbeat