Longest subsequence having equal numbers of 0 and 1

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)



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : vt_m



Article Tags :
Practice Tags :


1


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.