# Maximum size of subset such that product of all subset elements is a factor of N

• Last Updated : 11 Oct, 2021

Given an integer N and an array arr[] having M integers, the task is to find the maximum size of the subset such that the product of all elements of the subset is a factor of N.

Examples:

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.

Input: N = 12, arr[] = {2, 3, 4}
Output: 2
Explaination: The given array 5 subsets such that the product of all elements of the subset is a factor of 12. They are {2}, {3}, {4}, {2, 3} as (2 * 3) = 6, and {3, 4} as (3 * 4) = 12. Therefore, the maximum size of the valid subset is 2.

Input: N = 64, arr[] = {1, 2, 4, 8, 16, 32}
Output: 4

Approach: The given problem can be solved using recursion by traversing over all the subsets of the given array arr[] and keeping track of the size of the subsets such that N % (product of subset elements) = 0. Also for the product of the subset elements to be a factor of N, all individual elements of the array arr[] must also be a factor of N. Therefore, the above problem can be solved using the following steps:

• Create a recursive function maximizeSubset(), which calculates the maximum size of the required subset.
• If all the elements of the given array arr[] have been traversed, return 0 which is the base case.
• Iterate over all elements of the array arr[] and if N % arr[i] = 0, include arr[i] in a subset and recursively call for N = N/arr[i] for the remaining array elements.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the maximum size of``// the subset such that the product of``// subset elements is a factor of N``int` `maximizeSubset(``int` `N, ``int` `arr[],``                   ``int` `M, ``int` `x = 0)``{``    ``// Base Case``    ``if` `(x == M) {``        ``return` `0;``    ``}` `    ``// Stores maximum size of valid subset``    ``int` `ans = 0;` `    ``// Traverse the given array``    ``for` `(``int` `i = x; i < M; i++) {` `        ``// If N % arr[i] = 0, include arr[i]``        ``// in a subset and recursively call``        ``// for the remaining array integers``        ``if` `(N % arr[i] == 0) {``            ``ans = max(``                ``ans, maximizeSubset(``                         ``N / arr[i], arr,``                         ``M, x + 1)``                         ``+ 1);``        ``}``    ``}` `    ``// Return Answer``    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``int` `N = 64;``    ``int` `arr[] = { 1, 2, 4, 8, 16, 32 };``    ``int` `M = ``sizeof``(arr) / ``sizeof``(arr);` `    ``cout << maximizeSubset(N, arr, M);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG {` `    ``// Function to find the maximum size of``    ``// the subset such that the product of``    ``// subset elements is a factor of N``    ``static` `int` `maximizeSubset(``int` `N, ``int``[] arr, ``int` `M,``                              ``int` `x)``    ``{``        ``// Base Case``        ``if` `(x == M) {``            ``return` `0``;``        ``}` `        ``// Stores maximum size of valid subset``        ``int` `ans = ``0``;` `        ``// Traverse the given array``        ``for` `(``int` `i = x; i < M; i++) {` `            ``// If N % arr[i] = 0, include arr[i]``            ``// in a subset and recursively call``            ``// for the remaining array integers``            ``if` `(N % arr[i] == ``0``) {``                ``ans = Math.max(ans,``                               ``maximizeSubset(N / arr[i],``                                              ``arr, M, x + ``1``)``                                   ``+ ``1``);``            ``}``        ``}` `        ``// Return Answer``        ``return` `ans;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``64``;``        ``int``[] arr = { ``1``, ``2``, ``4``, ``8``, ``16``, ``32` `};``        ``int` `M = arr.length;` `        ``System.out.println(maximizeSubset(N, arr, M, ``0``));``    ``}``}` `// This code is contributed by ukasp.`

## Python3

 `# Python Program to implement``# the above approach` `# Function to find the maximum size of``# the subset such that the product of``# subset elements is a factor of N``def` `maximizeSubset(N, arr, M, x``=``0``):` `    ``# Base Case``    ``if` `(x ``=``=` `M):``        ``return` `0` `    ``# Stores maximum size of valid subset``    ``ans ``=` `0` `    ``# Traverse the given array``    ``for` `i ``in` `range``(x, M):` `        ``# If N % arr[i] = 0, include arr[i]``        ``# in a subset and recursively call``        ``# for the remaining array integers``        ``if` `(N ``%` `arr[i] ``=``=` `0``):``            ``ans ``=` `max``(``                ``ans, maximizeSubset(``                    ``N ``/``/` `arr[i], arr,``                    ``M, x ``+` `1``)``                ``+` `1``)` `    ``# Return Answer``    ``return` `ans`  `# Driver Code``N ``=` `64``arr ``=` `[``1``, ``2``, ``4``, ``8``, ``16``, ``32``]``M ``=` `len``(arr)` `print``(maximizeSubset(N, arr, M))` `# This code is contributed by Saurabh jaiswal`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to find the maximum size of``// the subset such that the product of``// subset elements is a factor of N``static` `int` `maximizeSubset(``int` `N, ``int` `[]arr,``                   ``int` `M, ``int` `x)``{``    ``// Base Case``    ``if` `(x == M) {``        ``return` `0;``    ``}` `    ``// Stores maximum size of valid subset``    ``int` `ans = 0;` `    ``// Traverse the given array``    ``for` `(``int` `i = x; i < M; i++) {` `        ``// If N % arr[i] = 0, include arr[i]``        ``// in a subset and recursively call``        ``// for the remaining array integers``        ``if` `(N % arr[i] == 0) {``            ``ans = Math.Max(``                ``ans, maximizeSubset(``                         ``N / arr[i], arr,``                         ``M, x + 1)``                         ``+ 1);``        ``}``    ``}` `    ``// Return Answer``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `N = 64;``    ``int` `[]arr = { 1, 2, 4, 8, 16, 32 };``    ``int` `M = arr.Length;` `    ``Console.Write(maximizeSubset(N, arr, M,0));``}``}` `// This code is contributed by ipg2016107.`

## Javascript

 ``
Output:
`4`

Time Complexity: O(2N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up