Related Articles

# Count of index subsets such that maximum of values over these indices in A is at least total sum over B

• Last Updated : 07 Oct, 2021

Given two arrays A[] and B[] consisting of N positive integers, the task is to find the total number of subsets of indices such that the maximum value in the array A[] over all these indices is greater than or equal to the sum of all values over these indices in the array B[].

Examples:

Input: A[] = {3, 1}, B[] = {1, 2}
Output: 2
Explanation:
The total possible valid subsets of indices are {0}, {0, 1}
{0}: max(3) >= sum(1)
{1, 2}: max(1, 3) >= sum(1, 2)

Input: A[] = {1, 3, 2, 6}, B[] = {7, 3, 2, 1}
Output: 6

Approach: The above problem can be solved using the concept discussed in the Subset Sum Problem with the help of Dynamic programming. The idea is to create a dp[][] of dimensions N*maximum element of the array A[]. Now, each node of the dp[][] matrix, i.e., dp[i][j] represents the number of subsets of the first i elements having sum j. Follow the below steps to solve this problem:

• Create a variable, say ans as 0 to store the total number of required subsets.
• Create a vector of pairs, say AB, and fill it with the elements of A & B, i.e., AB[i] = {A[i], B[i]}.
• Sort this vector of pairs on the basis of the first element.
• Initially dp table will be filled with zeroes except dp = 1.
• Traverse the array AB[] and consider the value of AB[i].first as the maximum because AB is sorted on the first element and it is maximum in the range [0, i] and in each iteration, traverse through all possible sums j and for each iteration calculate the subsets till index i having sum j by including and excluding the current element.
• After completing the above steps, traverse the matrix dp[][] and check how many subsets formed are valid by checking the following conditions. If it is found to be true, then add the value dp[i – 1][j] to the variable ans

j + AB[i – 1].second <= AB[i].first

• After completing the above steps, print the value of ans as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the number of non-empty``// subset of indices such that the maximum``// of values over these indices in A is``// at least the total sum over B[]``int` `countValidSubsets(``int` `A[], ``int` `B[], ``int` `N)``{``    ``int` `ans = 0;` `    ``vector > AB(N);` `    ``// Stores the maximum element in``    ``// the array A[]``    ``int` `mx = INT_MIN;` `    ``// Do the DP in 1-based indexing``    ``// as there will be no corner case``    ``// to handle specifically``    ``for` `(``int` `i = 0; i <= N; i++) {``        ``AB[i] = { A[i], B[i] };``        ``mx = max(mx, A[i]);``    ``}` `    ``// Sort the pair vector``    ``sort(AB.begin(), AB.end());` `    ``// dp matrix where dp[i][j] denotes``    ``// total valid subsets upto index``    ``// i with sum j``    ``vector > dp(``        ``N + 1, vector<``int``>(mx + 1, 0));` `    ``dp = 1;` `    ``// Traverse the array AB[]``    ``for` `(``int` `i = 1; i <= N; i++) {``        ``for` `(``int` `j = 0; j <= mx; j++) {` `            ``// Selecting the current``            ``// element in the subset``            ``if` `(j + AB[i - 1].second <= mx) {``                ``dp[i][j + AB[i - 1].second]``                    ``+= dp[i - 1][j];``            ``}` `            ``// Discarding the element``            ``dp[i][j] += dp[i - 1][j];``        ``}``    ``}` `    ``// Take the count of valid subsets``    ``for` `(``int` `i = 1; i <= N; ++i) {``        ``int` `cnt = 0;` `        ``// Iterate through all the``        ``// possible subsets``        ``for` `(``int` `j = 0; j <= mx; j++) {` `            ``// Check if the current subsets``            ``// till index i having sum j``            ``// are valid``            ``if` `(j + AB[i - 1].second``                ``<= AB[i - 1].first) {``                ``cnt += dp[i - 1][j];``            ``}``        ``}` `        ``// Update the value of ans``        ``ans += cnt;``    ``}` `    ``// Return the total count of subsets``    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``int` `A[] = { 1, 3, 2, 6 };``    ``int` `B[] = { 7, 3, 2, 1 };``    ``int` `N = ``sizeof``(A) / ``sizeof``(A);` `    ``cout << countValidSubsets(A, B, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{``    ``static` `class` `pair``    ``{``        ``int` `first, second;``        ``public` `pair(``int` `first, ``int` `second) ``        ``{``            ``this``.first = first;``            ``this``.second = second;``        ``}   ``    ``}``  ` `// Function to find the number of non-empty``// subset of indices such that the maximum``// of values over these indices in A is``// at least the total sum over B[]``static` `int` `countValidSubsets(``int` `A[], ``int` `B[], ``int` `N)``{``    ``int` `ans = ``0``;` `    ``pair []AB = ``new` `pair[N];` `    ``// Stores the maximum element in``    ``// the array A[]``    ``int` `mx = Integer.MIN_VALUE;` `    ``// Do the DP in 1-based indexing``    ``// as there will be no corner case``    ``// to handle specifically``    ``for` `(``int` `i = ``0``; i < N; i++) {``        ``AB[i] = ``new` `pair( A[i], B[i] );``        ``mx = Math.max(mx, A[i]);``    ``}` `    ``// Sort the pair vector``    ``Arrays.sort(AB,(a,b)->a.first-b.first);` `    ``// dp matrix where dp[i][j] denotes``    ``// total valid subsets upto index``    ``// i with sum j``    ``int``[][] dp= ``new` `int``[N + ``1``][mx + ``1``];` `    ``dp[``0``][``0``] = ``1``;` `    ``// Traverse the array AB[]``    ``for` `(``int` `i = ``1``; i <= N; i++) {``        ``for` `(``int` `j = ``0``; j <= mx; j++) {` `            ``// Selecting the current``            ``// element in the subset``            ``if` `(j + AB[i - ``1``].second <= mx) {``                ``dp[i][j + AB[i - ``1``].second]``                    ``+= dp[i - ``1``][j];``            ``}` `            ``// Discarding the element``            ``dp[i][j] += dp[i - ``1``][j];``        ``}``    ``}` `    ``// Take the count of valid subsets``    ``for` `(``int` `i = ``1``; i <= N; ++i) {``        ``int` `cnt = ``0``;` `        ``// Iterate through all the``        ``// possible subsets``        ``for` `(``int` `j = ``0``; j <= mx; j++) {` `            ``// Check if the current subsets``            ``// till index i having sum j``            ``// are valid``            ``if` `(j + AB[i - ``1``].second``                ``<= AB[i - ``1``].first) {``                ``cnt += dp[i - ``1``][j];``            ``}``        ``}` `        ``// Update the value of ans``        ``ans += cnt;``    ``}` `    ``// Return the total count of subsets``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `A[] = { ``1``, ``3``, ``2``, ``6` `};``    ``int` `B[] = { ``7``, ``3``, ``2``, ``1` `};``    ``int` `N = A.length;` `    ``System.out.print(countValidSubsets(A, B, N));` `}``}` `// This code is contributed by shikhasingrajput`

## Python3

 `# python program for the above approach``INT_MIN ``=` `-``2147483648` `# Function to find the number of non-empty``# subset of indices such that the maximum``# of values over these indices in A is``# at least the total sum over B[]``def` `countValidSubsets(A, B, N):``    ``ans ``=` `0``    ``AB ``=` `[[``0` `for` `_ ``in` `range``(``2``)] ``for` `_ ``in` `range``(N)]` `    ``# Stores the maximum element in``    ``# the array A[]``    ``mx ``=` `INT_MIN` `    ``# Do the DP in 1-based indexing``    ``# as there will be no corner case``    ``# to handle specifically``    ``for` `i ``in` `range``(``0``, N):``        ``AB[i] ``=` `[A[i], B[i]]``        ``mx ``=` `max``(mx, A[i])` `        ``# Sort the pair vector``    ``AB.sort()` `    ``# dp matrix where dp[i][j] denotes``    ``# total valid subsets upto index``    ``# i with sum j``    ``dp ``=` `[[``0` `for` `_ ``in` `range``(mx``+``1``)] ``for` `_ ``in` `range``(N``+``1``)]` `    ``dp[``0``][``0``] ``=` `1` `    ``# Traverse the array AB[]``    ``for` `i ``in` `range``(``1``, N``+``1``):``        ``for` `j ``in` `range``(``0``, mx``+``1``):` `                        ``# Selecting the current``                        ``# element in the subset``            ``if` `(j ``+` `AB[i ``-` `1``][``1``] <``=` `mx):``                ``dp[i][j ``+` `AB[i ``-` `1``][``1``]] ``+``=` `dp[i ``-` `1``][j]` `                ``# Discarding the element``            ``dp[i][j] ``+``=` `dp[i ``-` `1``][j]` `        ``# Take the count of valid subsets``    ``for` `i ``in` `range``(``1``, N``+``1``):``        ``cnt ``=` `0` `        ``# Iterate through all the``        ``# possible subsets``        ``for` `j ``in` `range``(``0``, mx``+``1``):` `                        ``# Check if the current subsets``                        ``# till index i having sum j``                        ``# are valid``            ``if` `(j ``+` `AB[i ``-` `1``][``1``] <``=` `AB[i ``-` `1``][``0``]):``                ``cnt ``+``=` `dp[i ``-` `1``][j]` `                ``# Update the value of ans``        ``ans ``+``=` `cnt` `        ``# Return the total count of subsets``    ``return` `ans` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``A ``=` `[``1``, ``3``, ``2``, ``6``]``    ``B ``=` `[``7``, ``3``, ``2``, ``1``]``    ``N ``=` `len``(A)` `    ``print``(countValidSubsets(A, B, N))` `    ``# This code is contributed by rakeshsahni`

## Javascript

 ``
Output:
`6`

Time Complexity: O(N*M), where M is the maximum element in the array.
Auxiliary Space: O(N*M)

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up