Related Articles

Related Articles

Longest subsequence having equal numbers of 0 and 1
  • Difficulty Level : Easy
  • Last Updated : 25 May, 2018

Given a binary array, the task is 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

#include <bits/stdc++.h>
using namespace std;
  
int generateSubsequences(int arr[], 
                         int n)
{
    // store the maximum length 
    // sub_sequence having equal
    // number of zeros and ones
    int result = 0;
  
    // Number of subsequences is (2**n -1)
    unsigned int opsize = pow(2, n);
  
    // Run from counter 000..1 to 111..1
    for (int counter = 1; counter < opsize; 
                          counter++) 
    {
  
        // store count of zeros and one
        int countzero = 0;
        int countone = 0, current_size = 0;
  
        for (int j = 0; j < n; j++) 
        {
  
            // Check if jth bit in the
            // counter is set. If set 
            // then print jth element
            // from arr[] 
            if (counter & (1 << j)) 
              
            {
                if (arr[j])
                    countone++;
                else
                    countzero++;
                current_size++;
            }
        }
  
        // update maximum size
        if (countzero == countone)
            result = max(current_size, 
                              result);
    }
    return result;
}
  
// Driver Code
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for Longest subsequence
// having equal numbers of 0 and 1
import java.io.*;
class GFG {
      
static int generateSubsequences(int arr[], 
                                   int n)
{
      
    // store the maximum length 
    // sub_sequence having equal
    // number of zeros and ones
    int result = 0;
  
    // Number of subsequences 
    // is (2**n -1)
    long opsize = (long) Math.pow(2, n);
  
    // Run from counter 
    // 000..1 to 111..1
    for (int counter = 1; counter < opsize; 
                                counter++) 
    {
  
        // store count of zeros and one
        int countzero = 0;
        int countone = 0, current_size = 0;
  
        for (int j = 0; j < n; j++) 
        {
  
            // Check if jth bit in the
            // counter is set. If set 
            // then print jth element
            // from arr[] 
            if ((counter & (1 << j))>0
              
            {
                if (arr[j]>0)
                    countone++;
                else
                    countzero++;
                current_size++;
            }
        }
  
        // update maximum size
        if (countzero == countone)
            result = Math.max(current_size, 
                                   result);
    }
    return result;
}
  
    // Driver Code
    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));
    }
}
  
// This code is contributed by anuj_67.

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python code to find the 
# length of longest subsequence
# having equal no of 1 and 0
  
def generateSubsequences(a, n):
    result = 0
      
    # Number of subsequences
    # is (2**n -1)
    opsize = 2**n
      
    # Run from counter
    # 000..1 to 111..1
    for counter in range(opsize):
          
        # store count of zeros and one
        countzero, countone = 0, 0
        current_size = 0
          
        for j in range(n):
              
            # Check if jth bit in the 
            # counter is set. If set then 
            # print jth element from arr[]
            if counter & (1 << j):
                if arr[j] == True:
                    countone += 1
                else:
                    countzero += 1
                current_size += 1
          
        # update maximum size
        if countzero == countone:
            result = max(current_size, 
                         result)
    return result 
  
# Driver code
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))
  
  
# This code is contributed
# by "Abhishek Sharma 44"

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for Longest subsequence
// having equal numbers of 0 and 1
using System;
class GFG {
      
static int generateSubsequences(int []arr, 
                                int n)
{
      
    // store the maximum length 
    // sub_sequence having equal
    // number of zeros and ones
    int result = 0;
  
    // Number of subsequences 
    // is (2**n -1)
    uint opsize = (uint) Math.Pow(2, n);
  
    // Run from counter 
    // 000..1 to 111..1
    for (int counter = 1; counter < opsize; 
                                counter++) 
    {
  
        // store count of zeros and one
        int countzero = 0;
        int countone = 0, current_size = 0;
  
        for (int j = 0; j < n; j++) 
        {
  
            // Check if jth bit in the
            // counter is set. If set 
            // then print jth element
            // from arr[] 
            if ((counter & (1 << j))>0) 
              
            {
                if (arr[j]>0)
                    countone++;
                else
                    countzero++;
                current_size++;
            }
        }
  
        // update maximum size
        if (countzero == countone)
            result = Math.Max(current_size, 
                                result);
    }
    return result;
}
  
    // Driver Code
    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));
    }
}
  
// This code is contributed by anuj_67.

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP code to find the length 
// of longest subsequence have
// equal no of 1 and 0
  
function generateSubsequences($arr
                              $n)
{
      
    // store the maximum length
    // sub_sequence having equal
    // number of zeros and ones
    $result = 0;
  
    // Number of subsequences 
    // is (2**n -1)
    $opsize = pow(2, $n);
  
    // Run from counter 000..1 
    // to 111..1
    for ($counter = 1; $counter < $opsize
                       $counter++) 
    {
  
        // store count of zeros and one
        $countzero = 0;
        $countone = 0; $current_size = 0;
  
        for ($j = 0; $j < $n; $j++)
        {
  
            // Check if jth bit in
            // the counter is set
            // If set then print jth
            // element from arr[] 
            if ($counter & (1 << $j)) 
            {
                if ($arr[$j])
                    $countone++;
                else
                    $countzero++;
                $current_size++;
            }
        }
  
        // update maximum size
        if ($countzero == $countone)
            $result = max($current_size
                          $result);
    }
    return $result;
}
  
// Driver Code
$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);
      
// This code is contributed by anuj_67.
?>

chevron_right



Output :

largest Subsequences having equal number of 0 & 1 is 6

Time Complexity: (n*2^n)



 

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 larges 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 above idea

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// Efficient CPP program to find 
// length of the longest subsequence 
// with equal number of 0s and 1s.
#include <bits/stdc++.h>
using namespace std;
  
int largestSubsequences(int arr[], int n)
{
    // store count of zeros and one
    int countzero = 0, countone = 0;
  
    // traverse binary array and count
    // zeros and ones
    for (int i = 0; i < n; i++)
        if (arr[i])
            countone++;
        else
            countzero++;
  
    return min(countone, countzero) * 2;
}
  
// Driver program
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Efficient Java program to find 
// length of the longest subsequence
// with equal number of 0s and 1s.
import java.io.*;
import java.math.*;
  
class GFG 
{
    static int largestSubsequences(int arr[], 
                                   int n)
    {
        // store count of zeros and one
        int countzero = 0, countone = 0;
  
        // traverse binary array and count
        // zeros and ones
        for (int i = 0; i < n; i++)
            if (arr[i] == 1)
                countone++;
            else
                countzero++;
  
        return Math.min(countone, countzero) * 2;
    }
  
    // Driver Code
    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));
    }
}
  
// This code is contributed by Nikita Tiwari

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Efficient Pyhton code to find 
# length of the longest subsequence 
# with equal number of 0s and 1s.
  
def largestSubsequence(arr,n):
      
    # store count of zeros and one
    countzero = 0
    countone = 0
      
    # traverse binary array and count
    # zeros and ones
    for i in range(n):
        if arr[i]:
            countone += 1
        else:
            countzero += 1
    return min(countone, countzero) * 2
      
# Driver Code
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))
   
# This code is contributed
# by "Abhishek Sharma 44"

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// Efficient C# program to find 
// length of the longest subsequence 
// with equal number of 0s and 1s.
using System;
  
class GFG
{
    static int largestSubsequences(int[] arr,
                                   int n)
    {
        // store count of zeros and one
        int countzero = 0, countone = 0;
      
        // traverse binary array and 
        // count zeros and ones
        for (int i = 0; i < n; i++)
            if (arr[i] != 0)
                countone++;
            else
                countzero++;
      
        return Math.Min(countone, 
                        countzero) * 2;
    }
      
    // Driver Code
    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));
          
    }
  
// This code is contributed by Anuj_67

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// Efficient PHP program to find 
// length of the longest subsequence 
// with equal number of 0s and 1s.
  
function largestSubsequences( $arr, $n)
{
    // store count of zeros and one
    $countzero = 0; $countone = 0;
  
    // traverse binary array and 
    // count zeros and ones
    for ( $i = 0; $i < $n; $i++)
        if ($arr[$i])
            $countone++;
        else
            $countzero++;
  
    return min($countone, $countzero) * 2;
}
  
// Driver Code
$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);
  
// This code is contributed by Anuj_67.
?>

chevron_right


Output :

largest Subsequences having equal number of 0 & 1 is 6

Time Complexity : O(n)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up
Recommended Articles
Page :