 Open in App
Not now

# Minimum common element in subarrays of all possible lengths

• Last Updated : 31 May, 2022

Given an array arr[] consisting of N integers from the range [1, N]( repetition allowed ), the task is to find the minimum common element for each possible subarray length. If no such element exists for any particular length of the subarray, then print -1.

Examples:

Input: arr[] = {1, 3, 4, 5, 6, 7}
Output: -1 -1 -1 4 3 1
Explanation:
K = 1: No common element exists. Therefore, print -1.
K = 2: No common element exists. Therefore, print -1.
K = 3: No common element exists. Therefore, print -1.
K = 4: Since 4 is common in all subarrays of size 4, print 4.
K = 5: Since 3 and 4 is common in all subarrays of size 5, print 3 as it is the minimum.
K = 6: Print 1 as it is the minimum element in the array.

Input: arr[]: {1, 2, 2, 2, 1}
Output: -1 2 2 1 1

Approach: Follow the steps below to solve the problem:

• Traverse the array and store the last occurrence of every element in a Map.
• Initialize an array temp[] and store in it for each value, the maximum distance between any pair of consecutive repetitions of it in the array.
• Once the above step is completed, update temp[] by comparing temp[i] with the distance of the last occurrence of i from the end of the array.
• Now, store the minimum comment element for all subarrays of length 1 to N one by one and print them.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement the``// above approach` `#include ``using` `namespace` `std;` `// Function to find maximum distance``// between every two element``void` `max_distance(``int` `a[], ``int` `temp[], ``int` `n)``{``    ``// Stores index of last occurrence``    ``// of each array element``    ``map<``int``, ``int``> mp;` `    ``// Initialize temp[] with -1``    ``for` `(``int` `i = 1; i <= n; i++) {``        ``temp[i] = -1;``    ``}` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If array element has``        ``// not occurred previously``        ``if` `(mp.find(a[i]) == mp.end())` `            ``// Update index in temp``            ``temp[a[i]] = i + 1;` `        ``// Otherwise``        ``else` `            ``// Compare temp[a[i]] with distance``            ``// from its previous occurrence and``            ``// store the maximum``            ``temp[a[i]] = max(temp[a[i]],``                             ``i - mp[a[i]]);` `        ``mp[a[i]] = i;``    ``}` `    ``for` `(``int` `i = 1; i <= n; i++) {` `        ``// Compare temp[i] with distance``        ``// of its last occurrence from the end``        ``// of the array and store the maximum``        ``if` `(temp[i] != -1)``            ``temp[i] = max(temp[i], n - mp[i]);``    ``}``}` `// Function to find the minimum common``// element in subarrays of all possible lengths``void` `min_comm_ele(``int` `a[], ``int` `ans[],``                  ``int` `temp[], ``int` `n)``{``    ``// Function call to find a the maximum``    ``// distance between every pair of repetition``    ``max_distance(a, temp, n);` `    ``// Initialize ans[] to -1``    ``for` `(``int` `i = 1; i <= n; i++) {``        ``ans[i] = -1;``    ``}` `    ``for` `(``int` `i = 1; i <= n; i++) {` `        ``// Check if subarray of length``        ``// temp[i] contains i as one``        ``// of the common elements``        ``if` `(ans[temp[i]] == -1)``            ``ans[temp[i]] = i;``    ``}` `    ``for` `(``int` `i = 1; i <= n; i++) {` `        ``// Find the minimum of all``        ``// common elements``        ``if` `(i > 1 && ans[i - 1] != -1) {` `            ``if` `(ans[i] == -1)``                ``ans[i] = ans[i - 1];``            ``else``                ``ans[i] = min(ans[i],``                             ``ans[i - 1]);``        ``}` `        ``cout << ans[i] << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `N = 6;``    ``int` `a[] = { 1, 3, 4, 5, 6, 7 };``    ``int` `temp, ans;``    ``min_comm_ele(a, ans, temp, N);` `    ``return` `0;``}`

## Java

 `// Java program to implement the``// above approach``import` `java.util.*;` `class` `GFG{``   ` `// Function to find maximum distance``// between every two element``static` `void` `max_distance(``int` `a[], ``int` `temp[], ``int` `n)``{``    ` `    ``// Stores index of last occurrence``    ``// of each array element``    ``Map mp = ``new` `HashMap();` `    ``// Initialize temp[] with -1``    ``for``(``int` `i = ``1``; i <= n; i++)``    ``{``        ``temp[i] = -``1``;``    ``}` `    ``// Traverse the array``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ` `        ``// If array element has``        ``// not occurred previously``        ``if` `(mp.get(a[i]) == ``null``)``        ` `            ``// Update index in temp``            ``temp[a[i]] = i + ``1``;` `        ``// Otherwise``        ``else` `            ``// Compare temp[a[i]] with distance``            ``// from its previous occurrence and``            ``// store the maximum``            ``temp[a[i]] = Math.max(temp[a[i]],``                   ``i - mp.getOrDefault(a[i], ``0``));` `        ``mp.put(a[i], i);``    ``}` `    ``for``(``int` `i = ``1``; i <= n; i++)``    ``{``        ` `        ``// Compare temp[i] with distance``        ``// of its last occurrence from the end``        ``// of the array and store the maximum``        ``if` `(temp[i] != -``1``)``            ``temp[i] = Math.max(temp[i],``                               ``n - mp.getOrDefault(i, ``0``));``    ``}``}` `// Function to find the minimum common``// element in subarrays of all possible lengths``static` `void` `min_comm_ele(``int` `a[], ``int` `ans[],``                         ``int` `temp[], ``int` `n)``{``    ` `    ``// Function call to find a the maximum``    ``// distance between every pair of repetition``    ``max_distance(a, temp, n);` `    ``// Initialize ans[] to -1``    ``for``(``int` `i = ``1``; i <= n; i++)``    ``{``        ``ans[i] = -``1``;``    ``}` `    ``for``(``int` `i = ``1``; i <= n; i++)``    ``{``        ` `        ``// Check if subarray of length``        ``// temp[i] contains i as one``        ``// of the common elements``        ``if` `(temp[i] >= ``0` `&& ans[temp[i]] == -``1``)``            ``ans[temp[i]] = i;``    ``}` `    ``for``(``int` `i = ``1``; i <= n; i++)``    ``{``        ` `        ``// Find the minimum of all``        ``// common elements``        ``if` `(i > ``1` `&& ans[i - ``1``] != -``1``)``        ``{``            ``if` `(ans[i] == -``1``)``                ``ans[i] = ans[i - ``1``];``            ``else``                ``ans[i] = Math.min(ans[i],``                                  ``ans[i - ``1``]);``        ``}``        ``System.out.print(ans[i] + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``int` `N = ``6``;``    ``int` `a[] = { ``1``, ``3``, ``4``, ``5``, ``6``, ``7` `};``    ` `    ``int` `[]temp = ``new` `int``[``100``];``    ``Arrays.fill(temp, ``0``);``    ` `    ``int` `[]ans = ``new` `int``[``100``];``    ``Arrays.fill(ans, ``0``);``    ` `    ``min_comm_ele(a, ans, temp, N);``}``}` `// This code is contributed by SURENDRA_GANGWAR`

## Python3

 `# Python3 Program to implement``# the above approach` `# Function to find maximum``# distance between every``# two element``def` `max_distance(a, temp, n):` `    ``# Stores index of last``    ``# occurrence of each``    ``# array element``    ``mp ``=` `{}` `    ``# Initialize temp[]``    ``# with -1``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``temp[i] ``=` `-``1` `    ``# Traverse the array``    ``for` `i ``in` `range``(n):` `        ``# If array element has``        ``# not occurred previously``        ``if` `(a[i] ``not` `in` `mp):` `            ``# Update index in temp``            ``temp[a[i]] ``=` `i ``+` `1` `        ``# Otherwise``        ``else``:` `            ``# Compare temp[a[i]] with``            ``# distance from its previous``            ``# occurrence and store the maximum``            ``temp[a[i]] ``=` `max``(temp[a[i]],``                             ``i ``-` `mp[a[i]])` `        ``mp[a[i]] ``=` `i` `    ``for` `i ``in` `range``(``1``, n ``+` `1``):` `        ``# Compare temp[i] with``        ``# distance of its last``        ``# occurrence from the end``        ``# of the array and store``        ``# the maximum``        ``if` `(temp[i] !``=` `-``1``):``            ``temp[i] ``=` `max``(temp[i],``                          ``n ``-` `mp[i])` `# Function to find the minimum``# common element in subarrays``# of all possible lengths``def` `min_comm_ele(a, ans,``                 ``temp, n):` `    ``# Function call to find``    ``# a the maximum distance``    ``# between every pair of``    ``# repetition``    ``max_distance(a, temp, n)` `    ``# Initialize ans[] to -1``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``ans[i] ``=` `-``1` `    ``for` `i ``in` `range``(``1``, n ``+` `1``):` `        ``# Check if subarray of length``        ``# temp[i] contains i as one``        ``# of the common elements``        ``if` `(ans[temp[i]] ``=``=` `-``1``):``            ``ans[temp[i]] ``=` `i` `    ``for` `i ``in` `range``(``1``, n ``+` `1``):` `        ``# Find the minimum of all``        ``# common elements``        ``if` `(i > ``1` `and``            ``ans[i ``-` `1``] !``=` `-``1``):` `            ``if` `(ans[i] ``=``=` `-``1``):``                ``ans[i] ``=` `ans[i ``-` `1``]``            ``else``:``                ``ans[i] ``=` `min``(ans[i],``                             ``ans[i ``-` `1``])` `        ``print``(ans[i], end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``N ``=` `6``    ``a ``=` `[``1``, ``3``, ``4``, ``5``, ``6``, ``7``]``    ``temp ``=` `[``0``] ``*` `100``    ``ans ``=` `[``0``] ``*` `100``    ``min_comm_ele(a, ans,``                 ``temp, N)` `# This code is contributed by Chitranayal`

## C#

 `// C# program to implement the``// above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG {``    ` `    ``// Function to find maximum distance``    ``// between every two element``    ``static` `void` `max_distance(``int``[] a, ``int``[] temp, ``int` `n)``    ``{``         ` `        ``// Stores index of last occurrence``        ``// of each array element``        ``Dictionary<``int``, ``int``> mp = ``new` `Dictionary<``int``, ``int``>(); ``     ` `        ``// Initialize temp[] with -1``        ``for``(``int` `i = 1; i <= n; i++)``        ``{``            ``temp[i] = -1;``        ``}``     ` `        ``// Traverse the array``        ``for``(``int` `i = 0; i < n; i++)``        ``{``             ` `            ``// If array element has``            ``// not occurred previously``            ``if` `(!mp.ContainsKey(a[i]))``             ` `                ``// Update index in temp``                ``temp[a[i]] = i + 1;``     ` `            ``// Otherwise``            ``else``     ` `                ``// Compare temp[a[i]] with distance``                ``// from its previous occurrence and``                ``// store the maximum``                ``temp[a[i]] = Math.Max(temp[a[i]], i - mp[a[i]]);``            ` `            ``if``(mp.ContainsKey(a[i]))``            ``{``                ``mp[a[i]] = i;``            ``}``            ``else``{``                ``mp.Add(a[i], i);``            ``}``        ``}``     ` `        ``for``(``int` `i = 1; i <= n; i++)``        ``{``             ` `            ``// Compare temp[i] with distance``            ``// of its last occurrence from the end``            ``// of the array and store the maximum``            ``if` `(temp[i] != -1)``            ``{``                ``if``(mp.ContainsKey(i))``                ``{``                    ``temp[i] = Math.Max(temp[i], n - mp[i]);``                ``}``                ``else``{``                    ``temp[i] = Math.Max(temp[i], n);``                ``}``            ``}``        ``}``    ``}``     ` `    ``// Function to find the minimum common``    ``// element in subarrays of all possible lengths``    ``static` `void` `min_comm_ele(``int``[] a, ``int``[] ans,``                             ``int``[] temp, ``int` `n)``    ``{``         ` `        ``// Function call to find a the maximum``        ``// distance between every pair of repetition``        ``max_distance(a, temp, n);``     ` `        ``// Initialize ans[] to -1``        ``for``(``int` `i = 1; i <= n; i++)``        ``{``            ``ans[i] = -1;``        ``}``     ` `        ``for``(``int` `i = 1; i <= n; i++)``        ``{``             ` `            ``// Check if subarray of length``            ``// temp[i] contains i as one``            ``// of the common elements``            ``if` `(temp[i] >= 0 && ans[temp[i]] == -1)``                ``ans[temp[i]] = i;``        ``}``     ` `        ``for``(``int` `i = 1; i <= n; i++)``        ``{``             ` `            ``// Find the minimum of all``            ``// common elements``            ``if` `(i > 1 && ans[i - 1] != -1)``            ``{``                ``if` `(ans[i] == -1)``                    ``ans[i] = ans[i - 1];``                ``else``                    ``ans[i] = Math.Min(ans[i],``                                      ``ans[i - 1]);``            ``}``            ``Console.Write(ans[i] + ``" "``);``        ``}``    ``}` `  ``// Driver code``  ``static` `void` `Main()``  ``{``      ` `        ``int` `N = 6;``        ``int``[] a = { 1, 3, 4, 5, 6, 7 };``         ` `        ``int``[] temp = ``new` `int``;``        ``Array.Fill(temp, 0);``         ` `        ``int``[] ans = ``new` `int``;``        ``Array.Fill(ans, 0);``         ` `        ``min_comm_ele(a, ans, temp, N);``  ``}``}` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output:

`-1 -1 -1 4 3 1`

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

My Personal Notes arrow_drop_up