Longest subsequence having equal numbers of 0 and 1
Given a binary array, the task is to find the size of the largest sub_sequence which having equal number of zeros and one.
Examples :
Input : arr[] = { 1, 0, 0, 1, 0, 0, 0, 1 }
Output: 6
Input : arr[] = { 0, 0, 1, 1, 1, 1, 1, 0, 0 }
Output : 8
simple solution is that we generate all possible sub_sequence and find which sub_sequence have equal number of zeros & one ( it’s size should be maximum).
Below is the implementation of above idea
C++
#include <bits/stdc++.h>
using namespace std;
int generateSubsequences( int arr[],
int n)
{
int result = 0;
unsigned int opsize = pow (2, n);
for ( int counter = 1; counter < opsize;
counter++)
{
int countzero = 0;
int countone = 0, current_size = 0;
for ( int j = 0; j < n; j++)
{
if (counter & (1 << j))
{
if (arr[j])
countone++;
else
countzero++;
current_size++;
}
}
if (countzero == countone)
result = max(current_size,
result);
}
return result;
}
int main()
{
int arr[] = { 1, 0, 0, 1,
0, 0, 0, 1 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << "largest Subsequences having "
"equal number of 0 & 1 is "
<< generateSubsequences(arr, n);
return 0;
}
|
Java
import java.io.*;
class GFG {
static int generateSubsequences( int arr[],
int n)
{
int result = 0 ;
long opsize = ( long ) Math.pow( 2 , n);
for ( int counter = 1 ; counter < opsize;
counter++)
{
int countzero = 0 ;
int countone = 0 , current_size = 0 ;
for ( int j = 0 ; j < n; j++)
{
if ((counter & ( 1 << j))> 0 )
{
if (arr[j]> 0 )
countone++;
else
countzero++;
current_size++;
}
}
if (countzero == countone)
result = Math.max(current_size,
result);
}
return result;
}
public static void main (String[] args)
{
int arr[] = { 1 , 0 , 0 , 1 ,
0 , 0 , 0 , 1 };
int n = arr.length;
System.out.println( "largest Subsequences having " +
"equal number of 0 & 1 is " +
generateSubsequences(arr, n));
}
}
|
Python3
def generateSubsequences(a, n):
result = 0
opsize = 2 * * n
for counter in range (opsize):
countzero, countone = 0 , 0
current_size = 0
for j in range (n):
if counter & ( 1 << j):
if arr[j] = = True :
countone + = 1
else :
countzero + = 1
current_size + = 1
if countzero = = countone:
result = max (current_size,
result)
return result
arr = [ 1 , 0 , 0 , 1 , 0 , 0 , 0 , 1 ]
n = len (arr)
print ( "largest Subsequences having" +
" equal number of 0 & 1 is " ,
generateSubsequences(arr, n))
|
C#
using System;
class GFG {
static int generateSubsequences( int []arr,
int n)
{
int result = 0;
uint opsize = ( uint ) Math.Pow(2, n);
for ( int counter = 1; counter < opsize;
counter++)
{
int countzero = 0;
int countone = 0, current_size = 0;
for ( int j = 0; j < n; j++)
{
if ((counter & (1 << j))>0)
{
if (arr[j]>0)
countone++;
else
countzero++;
current_size++;
}
}
if (countzero == countone)
result = Math.Max(current_size,
result);
}
return result;
}
public static void Main ()
{
int []arr = { 1, 0, 0, 1,
0, 0, 0, 1 };
int n = arr.Length;
Console.WriteLine( "largest Subsequences having " +
"equal number of 0 & 1 is " +
generateSubsequences(arr, n));
}
}
|
PHP
<?php
function generateSubsequences( $arr ,
$n )
{
$result = 0;
$opsize = pow(2, $n );
for ( $counter = 1; $counter < $opsize ;
$counter ++)
{
$countzero = 0;
$countone = 0; $current_size = 0;
for ( $j = 0; $j < $n ; $j ++)
{
if ( $counter & (1 << $j ))
{
if ( $arr [ $j ])
$countone ++;
else
$countzero ++;
$current_size ++;
}
}
if ( $countzero == $countone )
$result = max( $current_size ,
$result );
}
return $result ;
}
$arr = array (1, 0, 0, 1, 0, 0, 0, 1);
$n = count ( $arr );
echo "largest Subsequences having " ,
"equal number of 0 & 1 is " ,
generateSubsequences( $arr , $n );
?>
|
Javascript
<script>
function generateSubsequences(arr, n)
{
var result = 0;
var opsize = Math.pow(2, n);
for ( var counter = 1; counter < opsize;
counter++)
{
var countzero = 0;
var countone = 0, current_size = 0;
for ( var j = 0; j < n; j++)
{
if (counter & (1 << j))
{
if (arr[j])
countone++;
else
countzero++;
current_size++;
}
}
if (countzero == countone)
result = Math.max(current_size,
result);
}
return result;
}
var arr = [ 1, 0, 0, 1,
0, 0, 0, 1 ];
var n = arr.length;
document.write( "largest Subsequences having " +
"equal number of 0 & 1 is "
+ generateSubsequences(arr, n));
</script>
|
Output:
largest Subsequences having equal number of 0 & 1 is 6
Time Complexity: (n*2^n)
Auxiliary Space: O(1)
Efficient solution is to count zeros & ones in a binary array and last return minimum between count of zeros & ones by multiplying it with 2.
arr[] = { 1, 0, 0, 1, 0, 0, 0, 1 }
output : 6
here largest sub_sequencer :
{ 1 0 0 1 0 1} or {1 0 1 0 0 1 }
If we observe carefully then we notice that
we just have to find minimum counts between
zeros & ones and multiplying it with 2
( because we always get even length sub_sequence)
Below is the implementation of the above idea:
C++
#include <bits/stdc++.h>
using namespace std;
int largestSubsequences( int arr[], int n)
{
int countzero = 0, countone = 0;
for ( int i = 0; i < n; i++)
if (arr[i])
countone++;
else
countzero++;
return min(countone, countzero) * 2;
}
int main()
{
int arr[] = { 1, 0, 0, 1, 0, 0, 0, 1 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << "largest Subsequences having "
<< "equal number of 0 & 1 is "
<< largestSubsequences(arr, n);
return 0;
}
|
Java
import java.io.*;
import java.math.*;
class GFG
{
static int largestSubsequences( int arr[],
int n)
{
int countzero = 0 , countone = 0 ;
for ( int i = 0 ; i < n; i++)
if (arr[i] == 1 )
countone++;
else
countzero++;
return Math.min(countone, countzero) * 2 ;
}
public static void main(String args[])
{
int arr[] = { 1 , 0 , 0 , 1 , 0 , 0 , 0 , 1 };
int n = arr.length;
System.out.println( "largest Subsequences having " +
"equal number of 0 & 1 is " +
largestSubsequences(arr, n));
}
}
|
Python3
def largestSubsequence(arr,n):
countzero = 0
countone = 0
for i in range (n):
if arr[i]:
countone + = 1
else :
countzero + = 1
return min (countone, countzero) * 2
arr = [ 1 , 0 , 0 , 1 , 0 , 0 , 0 , 1 ]
n = len (arr)
print ( "largest Subsequences having" +
" equal number of 0 & 1 is " ,
largestSubsequence(arr, n))
|
C#
using System;
class GFG
{
static int largestSubsequences( int [] arr,
int n)
{
int countzero = 0, countone = 0;
for ( int i = 0; i < n; i++)
if (arr[i] != 0)
countone++;
else
countzero++;
return Math.Min(countone,
countzero) * 2;
}
static void Main()
{
int [] arr = { 1, 0, 0, 1, 0, 0, 0, 1 };
int n = 8 ;
Console.Write( "largest Subsequences having" +
" equal number of 0 & 1 is " +
largestSubsequences(arr, n));
}
}
|
PHP
<?php
function largestSubsequences( $arr , $n )
{
$countzero = 0; $countone = 0;
for ( $i = 0; $i < $n ; $i ++)
if ( $arr [ $i ])
$countone ++;
else
$countzero ++;
return min( $countone , $countzero ) * 2;
}
$arr = array (1, 0, 0, 1,
0, 0, 0, 1);
$n = count ( $arr );
echo "largest Subsequences having " ,
"equal number of 0 & 1 is " ,
largestSubsequences( $arr , $n );
?>
|
Javascript
<script>
function largestSubsequences(arr, n)
{
var countzero = 0, countone = 0;
for ( var i = 0; i < n; i++)
if (arr[i])
countone++;
else
countzero++;
return Math.min(countone, countzero) * 2;
}
var arr = [1, 0, 0, 1, 0, 0, 0, 1 ];
var n = arr.length;
document.write( "largest Subsequences having "
+ "equal number of 0 & 1 is "
+ largestSubsequences(arr, n));
</script>
|
Output
largest Subsequences having equal number of 0 & 1 is 6
Time Complexity : O(n)
Auxiliary Space: O(1)
Last Updated :
07 Nov, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...