# Length of longest subset consisting of A 0s and B 1s from an array of strings | Set 2

• Last Updated : 16 Jun, 2021

Given an array arr[] consisting of N binary strings, and two integers A and B, the task is to find the length of the longest subset consisting of at most A 0s and B 1s.

Examples:

Input: arr[] = {“1”, “0”, “0001”, “10”, “111001”}, A = 5, B = 3
Output: 4
Explanation:
One possible way is to select the subset {arr, arr, arr, arr}.
Total number of 0s and 1s in all these strings are 5 and 3 respectively.
Also, 4 is the length of the longest subset possible.

Input: arr[] = {“0”, “1”, “10”}, A = 1, B = 1
Output: 2
Explanation:
One possible way is to select the subset {arr, arr}.
Total number of 0s and 1s in all these strings is 1 and 1 respectively.
Also, 2 is the length of the longest subset possible.

Naive Approach: Refer to the previous post of this article for the simplest approach to solve the problem.
Time Complexity: O(2N)
Auxiliary Space: O(1)

Dynamic Programming Approach: Refer to the previous post of this article for the Dynamic Programming approach.
Time Complexity: O(N*A*B)
Auxiliary Space: O(N * A * B)

Space-Optimized Dynamic Programming Approach: The space complexity in the above approach can be optimized based on the following observations:

• Initialize a 2D array, dp[A][B], where dp[i][j] represents the length of the longest subset consisting of at most i number of 0s and j number of 1s.
• To optimize the auxiliary space from the 3D table to the 2D table, the idea is to traverse the inner loops in reverse order.
• This ensures that whenever a value in dp[][] is changed, it will not be needed anymore in the current iteration.
• Therefore, the recurrence relation looks like this:

dp[i][j] = max (dp[i][j], dp[i – zeros][j – ones] + 1)
where zeros is the count of 0s and ones is the count of 1s in the current iteration.

Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the length of the``// longest subset of an array of strings``// with at most A 0s and B 1s``int` `MaxSubsetlength(vector arr,``                    ``int` `A, ``int` `B)``{``    ``// Initialize a 2D array with its``    ``// entries as 0``    ``int` `dp[A + 1][B + 1];``    ``memset``(dp, 0, ``sizeof``(dp));` `    ``// Traverse the given array``    ``for` `(``auto``& str : arr) {` `        ``// Store the count of 0s and 1s``        ``// in the current string``        ``int` `zeros = count(str.begin(),``                          ``str.end(), ``'0'``);``        ``int` `ones = count(str.begin(),``                         ``str.end(), ``'1'``);` `        ``// Iterate in the range [A, zeros]``        ``for` `(``int` `i = A; i >= zeros; i--)` `            ``// Iterate in the range [B, ones]``            ``for` `(``int` `j = B; j >= ones; j--)` `                ``// Update the value of dp[i][j]``                ``dp[i][j] = max(``                    ``dp[i][j],``                    ``dp[i - zeros][j - ones] + 1);``    ``}` `    ``// Print the result``    ``return` `dp[A][B];``}` `// Driver Code``int` `main()``{``    ``vector arr``        ``= { ``"1"``, ``"0"``, ``"0001"``,``            ``"10"``, ``"111001"` `};``    ``int` `A = 5, B = 3;``    ``cout << MaxSubsetlength(arr, A, B);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `GFG{` `// Function to find the length of the``// longest subset of an array of strings``// with at most A 0s and B 1s``static` `int` `MaxSubsetlength(String arr[],``                           ``int` `A, ``int` `B)``{``    ` `    ``// Initialize a 2D array with its``    ``// entries as 0``    ``int` `dp[][] = ``new` `int``[A + ``1``][B + ``1``];` `    ``// Traverse the given array``    ``for``(String str : arr)``    ``{``        ` `        ``// Store the count of 0s and 1s``        ``// in the current string``        ``int` `zeros = ``0``, ones = ``0``;``        ``for``(``char` `ch : str.toCharArray())``        ``{``            ``if` `(ch == ``'0'``)``                ``zeros++;``            ``else``                ``ones++;``        ``}` `        ``// Iterate in the range [A, zeros]``        ``for``(``int` `i = A; i >= zeros; i--)``        ` `            ``// Iterate in the range [B, ones]``            ``for``(``int` `j = B; j >= ones; j--)` `                ``// Update the value of dp[i][j]``                ``dp[i][j] = Math.max(``                    ``dp[i][j],``                    ``dp[i - zeros][j - ones] + ``1``);``    ``}` `    ``// Print the result``    ``return` `dp[A][B];``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``String arr[] = { ``"1"``, ``"0"``, ``"0001"``,``                     ``"10"``, ``"111001"` `};``    ``int` `A = ``5``, B = ``3``;``    ` `    ``System.out.println(MaxSubsetlength(arr, A, B));``}``}` `// This code is contributed by Kingash`

## Python3

 `# Python3 program for the above approach` `# Function to find the length of the``# longest subset of an array of strings``# with at most A 0s and B 1s``def` `MaxSubsetlength(arr, A, B):``    ` `    ``# Initialize a 2D array with its``    ``# entries as 0``    ``dp ``=` `[[``0` `for` `i ``in` `range``(B ``+` `1``)]``             ``for` `i ``in` `range``(A ``+` `1``)]` `    ``# Traverse the given array``    ``for` `str` `in` `arr:``        ` `        ``# Store the count of 0s and 1s``        ``# in the current string``        ``zeros ``=` `str``.count(``'0'``)``        ``ones ``=` `str``.count(``'1'``)` `        ``# Iterate in the range [A, zeros]``        ``for` `i ``in` `range``(A, zeros ``-` `1``, ``-``1``):` `            ``# Iterate in the range [B, ones]``            ``for` `j ``in` `range``(B, ones ``-` `1``, ``-``1``):` `                ``# Update the value of dp[i][j]``                ``dp[i][j] ``=` `max``(dp[i][j],``                               ``dp[i ``-` `zeros][j ``-` `ones] ``+` `1``)` `    ``# Print the result``    ``return` `dp[A][B]` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``"1"``, ``"0"``, ``"0001"``, ``"10"``, ``"111001"` `]``    ``A, B ``=` `5``, ``3``    ` `    ``print` `(MaxSubsetlength(arr, A, B))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG {` `  ``// Function to find the length of the``  ``// longest subset of an array of strings``  ``// with at most A 0s and B 1s``  ``static` `int` `MaxSubsetlength(``string``[] arr, ``int` `A, ``int` `B)``  ``{` `    ``// Initialize a 2D array with its``    ``// entries as 0``    ``int``[, ] dp = ``new` `int``[A + 1, B + 1];` `    ``// Traverse the given array``    ``foreach``(``string` `str ``in` `arr)``    ``{` `      ``// Store the count of 0s and 1s``      ``// in the current string``      ``int` `zeros = 0, ones = 0;``      ``foreach``(``char` `ch ``in` `str.ToCharArray())``      ``{``        ``if` `(ch == ``'0'``)``          ``zeros++;``        ``else``          ``ones++;``      ``}` `      ``// Iterate in the range [A, zeros]``      ``for` `(``int` `i = A; i >= zeros; i--)` `        ``// Iterate in the range [B, ones]``        ``for` `(``int` `j = B; j >= ones; j--)` `          ``// Update the value of dp[i][j]``          ``dp[i, j] = Math.Max(``          ``dp[i, j],``          ``dp[i - zeros, j - ones] + 1);``    ``}` `    ``// Print the result``    ``return` `dp[A, B];``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``string``[] arr = { ``"1"``, ``"0"``, ``"0001"``, ``"10"``, ``"111001"` `};``    ``int` `A = 5, B = 3;` `    ``Console.WriteLine(MaxSubsetlength(arr, A, B));``  ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``
Output:
`4`

Time Complexity: O(N * A * B)
Auxiliary Space: O(A * B)

My Personal Notes arrow_drop_up