# Count subsets having product divisible by K

• Last Updated : 24 Apr, 2021

Given an array arr[] of size N and an integer K, the task is to count the number of subsets from the given array with product of elements divisible by K

Examples:

Input: arr[] = {1, 2, 3, 4, 5}, K = 60
Output: 4
Explanation: Subsets whose product of elements is divisible by K(= 60) are { {1, 2, 3, 4, 5}, {2, 3, 4, 5}, {3, 4, 5}, {1, 3, 4, 5} }

Input: arr[] = {1, 2, 3, 4, 5, 6}, K = 60
Output: 16

Naive Approach: The simplest approach to solve this problem is to generate all possible subsets and for each subset, check if the product of its elements is divisible by K or not. If found to be true, then increment the count. Finally, print the count.

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

Efficient Approach: To optimize the above approach the idea is to use Dynamic programming. Below is the recurrence relation and the base case:

Recurrence Relation:
cntSubDivK(N, rem) = cntSubDivK(N – 1, (rem * arr[N – 1]) % K) + cntSubDivK(N – 1, rem).
cntSubDivK(N, rem) store the count of subset having product divisible by K.
rem: Store the remainder when K divides the product of all elements of the subset.

Base Case:
if N == 0 and rem == 0 then return 1
If N == 0 and rem != 0 then return 0.

Follow the steps below to solve the problem:

• Initialize a 2D array, say dp[N][rem] to compute and store the values of all subproblems of the above recurrence relation.
• Finally, return the value of dp[N][rem].

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Function to count the subsets whose``// product of elements is divisible by K``int` `cntSubDivK(``int` `arr[], ``int` `N, ``int` `K,``               ``int` `rem, vector >& dp)``{``    ``// If count of elements``    ``// in the array is 0``    ``if` `(N == 0) {` `        ``// If rem is 0, then return 1``        ``// Otherwise, return 0``        ``return` `rem == 0;``    ``}` `    ``// If already computed``    ``// subproblem occurred``    ``if` `(dp[N][rem] != -1) {``        ``return` `dp[N][rem];``    ``}` `    ``// Stores count of subsets having product``    ``// divisible by K when arr[N - 1]``    ``// present in the subset``    ``int` `X = cntSubDivK(arr, N - 1, K,``                       ``(rem * arr[N - 1]) % K, dp);` `    ``// Stores count of subsets having product``    ``// divisible by K when arr[N - 1] not``    ``// present in the subset``    ``int` `Y = cntSubDivK(arr, N - 1, K,``                       ``rem, dp);` `    ``// Return total subset``    ``return` `X + Y;``}` `// Utility Function to count the subsets whose``// product of elements is divisible by K``int` `UtilCntSubDivK(``int` `arr[], ``int` `N, ``int` `K)``{` `    ``// Initialize a 2D array to store values``    ``// of overlapping subproblems``    ``vector > dp(N + 1,``                            ``vector<``int``>(K + 1, -1));` `    ``return` `cntSubDivK(arr, N, K, 1, dp);``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 2, 3, 4, 5, 6 };``    ``int` `K = 60;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << UtilCntSubDivK(arr, N, K);``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;` `class` `GFG{``  ` `// Function to count the subsets whose``// product of elements is divisible by K``static` `int` `cntSubDivK(``int` `arr[], ``int` `N, ``int` `K,``                      ``int` `rem, ``int``[][]dp)``{``    ` `    ``// If count of elements``    ``// in the array is 0``    ``if` `(N == ``0``)``    ``{``        ` `        ``// If rem is 0, then return 1``        ``// Otherwise, return 0``        ``return` `rem == ``0` `? ``1` `: ``0``;``    ``}` `    ``// If already computed``    ``// subproblem occurred``    ``if` `(dp[N][rem] != -``1``)``    ``{``        ``return` `dp[N][rem];``    ``}` `    ``// Stores count of subsets having product``    ``// divisible by K when arr[N - 1]``    ``// present in the subset``    ``int` `X = cntSubDivK(arr, N - ``1``, K,``                       ``(rem * arr[N - ``1``]) % K, dp);` `    ``// Stores count of subsets having product``    ``// divisible by K when arr[N - 1] not``    ``// present in the subset``    ``int` `Y = cntSubDivK(arr, N - ``1``, K,``                       ``rem, dp);` `    ``// Return total subset``    ``return` `X + Y;``}` `// Utility Function to count the subsets whose``// product of elements is divisible by K``static` `int` `UtilCntSubDivK(``int` `arr[], ``int` `N, ``int` `K)``{``    ` `    ``// Initialize a 2D array to store values``    ``// of overlapping subproblems``    ``int` `[][]dp = ``new` `int``[N + ``1``][K + ``1``];``    ` `    ``for``(``int` `i = ``0``; i < N + ``1``; i++)``    ``{``        ``for``(``int` `j = ``0``; j < K + ``1``; j++)``            ``dp[i][j] = -``1``;``    ``}``    ``return` `cntSubDivK(arr, N, K, ``1``, dp);``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``int` `arr[] = { ``1``, ``2``, ``3``, ``4``, ``5``, ``6` `};``    ``int` `K = ``60``;``    ``int` `N = arr.length;``    ` `    ``System.out.println(UtilCntSubDivK(arr, N, K));``}``}` `// This code is contributed by SURENDRA_GANGWAR`

## Python3

 `# Python3 program to``# implement the above``# approach` `# Function to count the``# subsets whose product``# of elements is divisible``# by K``def` `cntSubDivK(arr, N, K,``               ``rem, dp):` `    ``# If count of elements``    ``# in the array is 0``    ``if` `(N ``=``=` `0``):` `        ``# If rem is 0, then``        ``# return 1 Otherwise,``        ``# return 0``        ``return` `rem ``=``=` `0` `    ``# If already computed``    ``# subproblem occurred``    ``if` `(dp[N][rem] !``=` `-``1``):``        ``return` `dp[N][rem]` `    ``# Stores count of subsets``    ``# having product divisible``    ``# by K when arr[N - 1]``    ``# present in the subset``    ``X ``=` `cntSubDivK(arr, N ``-` `1``, K,``                   ``(rem ``*` `arr[N ``-` `1``]) ``%` `K, dp)` `    ``# Stores count of subsets having``    ``# product divisible by K when``    ``# arr[N - 1] not present in``    ``# the subset``    ``Y ``=` `cntSubDivK(arr, N ``-` `1``,``                   ``K, rem, dp)` `    ``# Return total subset``    ``return` `X ``+` `Y` `# Utility Function to count``# the subsets whose product of``# elements is divisible by K``def` `UtilCntSubDivK(arr, N, K):` `    ``# Initialize a 2D array to``    ``# store values of overlapping``    ``# subproblems``    ``dp ``=` `[[``-``1` `for` `x ``in` `range``(K ``+` `1``)]``              ``for` `y ``in` `range``(N ``+` `1``)]` `    ``return` `cntSubDivK(arr, N,``                      ``K, ``1``, dp)``  ` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``1``, ``2``, ``3``,``           ``4``, ``5``, ``6``]``    ``K ``=` `60``    ``N ``=` `len``(arr)``    ``print``(UtilCntSubDivK(arr, N, K))` `# This code is contributed by Chitranayal`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG{``    ` `// Function to count the subsets whose``// product of elements is divisible by K``static` `int` `cntSubDivK(``int``[] arr, ``int` `N, ``int` `K,``                      ``int` `rem, ``int``[,] dp)``{``    ` `    ``// If count of elements``    ``// in the array is 0``    ``if` `(N == 0)``    ``{``        ` `        ``// If rem is 0, then return 1``        ``// Otherwise, return 0``        ``return` `rem == 0 ? 1 : 0;``    ``}`` ` `    ``// If already computed``    ``// subproblem occurred``    ``if` `(dp[N, rem] != -1)``    ``{``        ``return` `dp[N, rem];``    ``}``    ` `    ``// Stores count of subsets having product``    ``// divisible by K when arr[N - 1]``    ``// present in the subset``    ``int` `X = cntSubDivK(arr, N - 1, K,``                      ``(rem * arr[N - 1]) % K, dp);``                      ` `    ``// Stores count of subsets having product``    ``// divisible by K when arr[N - 1] not``    ``// present in the subset``    ``int` `Y = cntSubDivK(arr, N - 1, K,``                       ``rem, dp);``                       ` `    ``// Return total subset``    ``return` `X + Y;``}`` ` `// Utility Function to count the subsets whose``// product of elements is divisible by K``static` `int` `UtilCntSubDivK(``int``[] arr, ``int` `N, ``int` `K)``{``    ` `    ``// Initialize a 2D array to store values``    ``// of overlapping subproblems``    ``int``[,] dp = ``new` `int``[N + 1, K + 1];``     ` `    ``for``(``int` `i = 0; i < N + 1; i++)``    ``{``        ``for``(``int` `j = 0; j < K + 1; j++)``            ``dp[i, j] = -1;``    ``}``    ``return` `cntSubDivK(arr, N, K, 1, dp);``}` `// Driver code``static` `void` `Main()``{``    ``int``[] arr = { 1, 2, 3, 4, 5, 6 };``    ``int` `K = 60;``    ``int` `N = arr.Length;` `    ``Console.WriteLine(UtilCntSubDivK(arr, N, K));``}``}` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output:

`16`

Time Complexity: O(N * K)
Space Complexity: O(N * K)

My Personal Notes arrow_drop_up