Check if all subarrays contains at least one unique element
Last Updated :
11 Jul, 2022
Given an array arr[] consisting of N integers, the task is to check if all subarrays of the array have at least one unique element in it or not. If found to be true, then print “Yes”. Otherwise, print “No”.
Examples:
Input: arr[] = {1, 2, 1}
Output: Yes
Explanation:
For Subarrays of size 1: {1}, {2}, {1}, the condition will always be true.
For Subarrays of size 2: {1, 2}, {2, 1}, each subarray has at least one unique element.
For Subarrays of size 3 = {1, 2, 1}, in this subarray we have 2 as the only unique element.
Since each subarray has at least one unique element, print “Yes”.
Input: arr[] = {1, 2, 3, 1, 2, 3}
Output: No
Explanation:
Subarrays of size 6: {1, 2, 3, 1, 2, 3} contains no unique element. Therefore, print “No”.
Naive Approach: The simplest approach is to generate all subarrays and use HashMap for each subarray to store the frequency of each element of that subarray. If any subarray does not have at least one unique element, then print “No”. Otherwise, print “Yes”.
Below is the implementation of the above approach:
C++
#include<bits/stdc++.h>
using namespace std;
string check( int arr[], int n)
{
map< int , int > hm;
for ( int i = 0; i < n; i++)
{
hm[arr[i]] = 1;
for ( int j = i + 1; j < n; j++)
{
hm[arr[j]]++;
bool flag = false ;
for ( auto x : hm)
{
if (x.second == 1)
{
flag = true ;
break ;
}
}
if (!flag)
return "No" ;
}
hm.clear();
}
return "Yes" ;
}
int main()
{
int arr[] = { 1, 2, 1 };
int N = sizeof (arr) / sizeof (arr[0]);
cout << check(arr, N);
}
|
Java
import java.util.*;
import java.lang.*;
class GFG {
static String check( int arr[], int n)
{
Map<Integer, Integer> hm
= new HashMap<>();
for ( int i = 0 ; i < n; i++) {
hm.put(arr[i], 1 );
for ( int j = i + 1 ; j < n; j++) {
hm.put(
arr[j],
hm.getOrDefault(arr[j], 0 ) + 1 );
boolean flag = false ;
for (Integer k : hm.values()) {
if (k == 1 ) {
flag = true ;
break ;
}
}
if (!flag)
return "No" ;
}
hm.clear();
}
return "Yes" ;
}
public static void main(String[] args)
{
int [] arr = { 1 , 2 , 1 };
int N = arr.length;
System.out.println(check(arr, N));
}
}
|
Python3
from collections import defaultdict
def check(arr, n):
hm = defaultdict ( int )
for i in range (n):
hm[arr[i]] + = 1
for j in range (i + 1 , n):
hm[arr[j]] + = 1
flag = False
for k in hm.values():
if (k = = 1 ):
flag = True
break
if ( not flag):
return "No"
hm.clear()
return "Yes"
if __name__ = = "__main__" :
arr = [ 1 , 2 , 1 ]
N = len (arr)
print (check(arr, N))
|
C#
using System;
using System.Collections.Generic;
class GFG{
static String check( int []arr,
int n)
{
Dictionary< int ,
int > hm =
new Dictionary< int ,
int >();
for ( int i = 0; i < n; i++)
{
hm.Add(arr[i], 1);
for ( int j = i + 1; j < n; j++)
{
if (hm.ContainsKey(arr[j]))
hm[arr[j]]++;
else
hm.Add(arr[j], 1);
bool flag = false ;
foreach ( int k in hm.Values)
{
if (k == 1)
{
flag = true ;
break ;
}
}
if (!flag)
return "No" ;
}
hm.Clear();
}
return "Yes" ;
}
public static void Main(String[] args)
{
int [] arr = {1, 2, 1};
int N = arr.Length;
Console.WriteLine(check(arr, N));
}
}
|
Javascript
<script>
function check(arr, n)
{
var hm = new Map();
for ( var i = 0; i < n; i++)
{
hm.set(arr[i], 1);
for ( var j = i + 1; j < n; j++)
{
if (hm.has(arr[j]))
hm.set(arr[j], hm.get(arr[j])+1);
else
hm.set(arr[j], 1)
var flag = false ;
hm.forEach((value, key) => {
if (value == 1)
{
flag = true ;
}
});
if (!flag)
return "No" ;
}
hm = new Map();
}
return "Yes" ;
}
var arr = [1, 2, 1];
var N = arr.length;
document.write( check(arr, N));
</script>
|
Time Complexity: O(N3)
Auxiliary Space: O(N)
Efficient Approach: Follow the steps below to optimize the above approach:
- Iterate a loop over the range [0, N – 1] and create a map to store the frequency of each character present in the current subarray.
- Create a variable count to check that subarray has at least one element with frequency 1 or not.
- Traverse the array arr[] and update the frequency of each element in the map and update the count as:
- If the frequency of element is 1 then increment the count.
- If the frequency of element is 2 then decrement the count.
- In the above steps, if the value of count is 0, then print “No” as there exists a subarray who doesn’t have any unique element in it.
- After all the iteration if the value of count is always positive, then print “Yes”.
Below is the implementation of the above approach:
C++
#include<bits/stdc++.h>
using namespace std;
string check( int arr[], int n)
{
for ( int i = 0; i < n; i++)
{
map< int , int > hm;
int count = 0;
for ( int j = i; j < n; j++)
{
hm[arr[j]]++;
if (hm[arr[j]] == 1)
count++;
if (hm[arr[j]] == 2)
count--;
if (count == 0)
return "No" ;
}
}
return "Yes" ;
}
int main()
{
int arr[] = { 1, 2, 1 };
int N = sizeof (arr) / sizeof (arr[0]);
cout << check(arr, N);
}
|
Java
import java.util.*;
import java.lang.*;
class GFG {
static String check( int arr[], int n)
{
for ( int i = 0 ; i < n; i++) {
Map<Integer, Integer> hm
= new HashMap<>();
int count = 0 ;
for ( int j = i; j < n; j++) {
hm.put(arr[j],
hm.getOrDefault(arr[j], 0 ) + 1 );
if (hm.get(arr[j]) == 1 )
count++;
if (hm.get(arr[j]) == 2 )
count--;
if (count == 0 )
return "No" ;
}
}
return "Yes" ;
}
public static void main(String[] args)
{
int [] arr = { 1 , 2 , 1 };
int N = arr.length;
System.out.println(check(arr, N));
}
}
|
Python3
def check(arr, n):
for i in range (n):
hm = {}
count = 0
for j in range (i, n):
hm[arr[j]] = hm.get(arr[j], 0 ) + 1
if (hm[arr[j]] = = 1 ):
count + = 1
if (hm[arr[j]] = = 2 ):
count - = 1
if (count = = 0 ):
return "No"
return "Yes"
if __name__ = = '__main__' :
arr = [ 1 , 2 , 1 ]
N = len (arr)
print (check(arr, N))
|
C#
using System;
using System.Collections.Generic;
class GFG {
static String check( int []arr,
int n)
{
for ( int i = 0; i < n; i++)
{
Dictionary< int ,
int > hm =
new Dictionary< int ,
int >();
int count = 0;
for ( int j = i; j < n; j++)
{
if (hm.ContainsKey((arr[j])))
hm[arr[j]]++;
else
hm.Add(arr[j], 1);
if (hm[arr[j]] == 1)
count++;
if (hm[arr[j]] == 2)
count--;
if (count == 0)
return "No" ;
}
}
return "Yes" ;
}
public static void Main(String[] args)
{
int [] arr = {1, 2, 1};
int N = arr.Length;
Console.WriteLine(check(arr, N));
}
}
|
Javascript
<script>
function check(arr, n)
{
for ( var i = 0; i < n; i++)
{
var hm= new Map();
var count = 0;
for ( var j = i; j < n; j++)
{
if (hm.has(arr[j]))
hm.set(arr[j], hm.get(arr[j])+1)
else
hm.set(arr[j], 1)
if (hm.get(arr[j])==1)
count++;
if (hm.get(arr[j]) == 2)
count--;
if (count == 0)
return "No" ;
}
}
return "Yes" ;
}
var arr = [ 1, 2, 1 ];
var N = arr.length;
document.write(check(arr, N));
</script>
|
Time Complexity: O(N2)
Auxiliary Space: O(N)
Related Topic: Subarrays, Subsequences, and Subsets in Array
Share your thoughts in the comments
Please Login to comment...