Longest subsequence having equal numbers of 0 and 1

• Difficulty Level : Easy
• Last Updated : 11 May, 2021

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 ``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;``}`

Java

 `// 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.`

Python3

 `# 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"`

C#

 `// 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.`

PHP

 ``

Javascript

 ``

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++

 `// Efficient CPP program to find``// length of the longest subsequence``// with equal number of 0s and 1s.``#include ``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;``}`

Java

 `// 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`

Python3

 `# 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"`

C#

 `// 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`

PHP

 ``

Javascript

 ``

Output:

`largest Subsequences having equal number of 0 & 1 is 6`

Time Complexity : O(n)

My Personal Notes arrow_drop_up