Number of subsets with sum divisible by m - GeeksforGeeks

04 Feb, 2022
Given an array of integers, find a number of subsequences such that the sum of the subsequence is divisible by m. It is given that sum of array elements is small. Examples: 
Input : arr[] = {1, 2, 3};
        m = 3;
Output : 3
Subsequence of given set are
{1}, {2}, {3}, {1, 2}, {2, 3}, {1, 3} and {1, 2, 3}. 
And their sums are 1, 2, 3, 3, 5, 4 and 6.

Input : arr[] = {1, 2, 3, 4};
        m = 2;
Output : 7
{2}, {4}, {1, 3}, {2, 4}, {1, 2, 3}, {1, 3, 4} 
and {1, 2, 3, 4}
A simple solution is to generate all possible subsets. For every subset, compute its sum, and if the sum is multiple of m, increment result by 1. The time complexity of this approach is O(2len) where len is the length of the input array.An efficient solution (for small values) is based on Dynamic Programming solution of subset sum problem. We make a 2D array of size sum x n.  
C++
Java
Python3
C#
Javascript
// C++ program which returns the Number of sub sequences// (or subsets) which are divisible by m.#include <bits/stdc++.h>using namespace std; // Use Dynamic Programming to find// sum of subsequences.int sumSubSequence(vector<int> arr, int len, int m){    // Find sum of array elements    int sum = 0;    for (auto x : arr)       sum += x;     // dp[i][j] would be > 0 if arr[0..i-1] has    // a subsequence with sum equal to j.    vector<vector<int> > dp(len + 1, vector<int>(sum + 1, 0));     // There is always sum equals zero    for (int i = 0; i <= len; i++)        dp[i][0]++;      // Fill up the dp table    for (int i = 1; i <= len; i++) {         dp[i][arr[i - 1]]++;        for (int j = 1; j <= sum; j++) {             if (dp[i - 1][j] > 0) {                dp[i][j]++;                dp[i][j + arr[i - 1]]++;            }        }    }     // Initialize the counter    int count = 0;    for (int j = 1; j <= sum; j++)         // Check if the sum exists        if (dp[len][j] > 0)             // check sum is divisible by m            if (j % m == 0)                count += dp[len][j];     return count;} // Driver Codeint main(){    vector<int> arr{ 1, 2, 3 };    int m = 3;    int len = arr.size();    cout << sumSubSequence(arr, len, m) << endl;    return 0;}
// Java program which returns the Number of sub sequences// (or subsets) which are divisible by m. class GFG{ // Use Dynamic Programming to find// sum of subsequences.static int sumSubSequence(int []arr, int len, int m){    // Find sum of array elements    int sum = 0;    for (int x : arr)    {        sum += x;    }     // dp[i][j] would be > 0 if arr[0..i-1] has    // a subsequence with sum equal to j.    int [][]dp = new int[len + 1][sum + 1];     // There is always sum equals zero    for (int i = 0; i <= len; i++)        dp[i][0]++;     // Fill up the dp table    for (int i = 1; i <= len; i++)    {         dp[i][arr[i - 1]]++;        for (int j = 1; j <= sum; j++)        {             if (dp[i - 1][j] > 0)            {                dp[i][j]++;                dp[i][j + arr[i - 1]]++;            }        }    }     // Initialize the counter    int count = 0;    for (int j = 1; j <= sum; j++)         // Check if the sum exists        if (dp[len][j] > 0)             // check sum is divisible by m            if (j % m == 0)                count += dp[len][j];     return count;} // Driver Codepublic static void main(String[] args){    int []arr = { 1, 2, 3 };    int m = 3;    int len = arr.length;    System.out.print(sumSubSequence(arr, len, m) +"\n");}} // This code is contributed by Rajput-Ji
# Python3 program which returns# the Number of sub sequences# (or subsets) which are divisible by m. # Use Dynamic Programming to find# sum of subsequences.def sumSubSequence(arr, length, m):     # Find sum of array elements    summ = 0    for i in arr:        summ += i     # dp[i][j] would be > 0 if arr[0..i-1] has    # a subsequence with sum equal to j.    dp = [[0 for i in range(summ + 1)]             for j in range(length + 1)]     # There is always sum equals zero    for i in range(length + 1):        dp[i][0] += 1     # Fill up the dp table    for i in range(1, length + 1):        dp[i][arr[i - 1]] += 1        for j in range(1, summ + 1):            if dp[i - 1][j] > 0:                dp[i][j] += 1                dp[i][j + arr[i - 1]] += 1     # Initialize the counter    count = 0    for i in range(1, summ + 1):         # Check if the sum exists        if dp[length][i] > 0:             # check sum is divisible by m            if i % m == 0:                count += dp[length][i]     return count # Driver Codeif __name__ == "__main__":    arr = [1, 2, 3]    m = 3    length = len(arr)    print(sumSubSequence(arr, length, m)) # This code is contributed by# sanjeev2552
// C# program which returns// the Number of sub sequences// (or subsets) which are// divisible by m.using System;class GFG{ // Use Dynamic Programming// to find sum of subsequences.static int sumSubSequence(int []arr,                          int len,                          int m){  // Find sum of array elements  int sum = 0;  foreach (int x in arr)  {    sum += x;  }   // dp[i][j] would be > 0 if  // arr[0..i-1] has a  // subsequence with sum equal  // to j.  int [,]dp = new int[len + 1,                      sum + 1];   // There is always sum equals  // zero  for (int i = 0; i <= len; i++)    dp[i, 0]++;   // Fill up the dp table  for (int i = 1; i <= len; i++)  {    dp[i, arr[i - 1]]++;    for (int j = 1; j <= sum; j++)    {      if (dp[i - 1, j] > 0)      {        dp[i, j]++;        dp[i, j + arr[i - 1]]++;      }    }  }   // Initialize the counter  int count = 0;  for (int j = 1; j <= sum; j++)     // Check if the sum exists    if (dp[len, j] > 0)       // check sum is divisible      // by m      if (j % m == 0)        count += dp[len, j];   return count;} // Driver Codepublic static void Main(string[] args){  int []arr = {1, 2, 3};  int m = 3;  int len = arr.Length;  Console.Write(  sumSubSequence(arr,                 len, m) + "\n");}} // This code is contributed by Chitranayal
<script>// Javascript program which returns the Number of sub sequences// (or subsets) which are divisible by m. // Use Dynamic Programming to find// sum of subsequences.function sumSubSequence(arr,len,m){    // Find sum of array elements    let sum = 0;    for (let x=0;x<arr.length;x++)    {        sum += arr[x];    }      // dp[i][j] would be > 0 if arr[0..i-1] has    // a subsequence with sum equal to j.    let dp = new Array(len + 1);    for(let i=0;i<dp.length;i++)    {        dp[i]=new Array(sum+1);        for(let j=0;j<dp[i].length;j++)        {            dp[i][j]=0;        }    }      // There is always sum equals zero    for (let i = 0; i <= len; i++)        dp[i][0]++;      // Fill up the dp table    for (let i = 1; i <= len; i++)    {          dp[i][arr[i - 1]]++;        for (let j = 1; j <= sum; j++)        {              if (dp[i - 1][j] > 0)            {                dp[i][j]++;                dp[i][j + arr[i - 1]]++;            }        }    }      // Initialize the counter    let count = 0;    for (let j = 1; j <= sum; j++)          // Check if the sum exists        if (dp[len][j] > 0)              // check sum is divisible by m            if (j % m == 0)                count += dp[len][j];      return count;} // Driver Codelet arr=[ 1, 2, 3];let m = 3;let len = arr.length;document.write(sumSubSequence(arr, len, m) +"<br>"); // This code is contributed by avanitrachhadiya2155</script>
3
 
The time complexity of the above approach is O(len*sum) where len is the size of the array and sum is the sum of all the integers in the array.
sanjeev2552
Rajput-Ji
ukasp
avanitrachhadiya2155
sagar0719kumar
subsequence
subset
Arrays
Dynamic Programming
Arrays
Dynamic Programming
subset
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Stack Data Structure (Introduction and Program)
Introduction to Arrays
Multidimensional Arrays in Java
0-1 Knapsack Problem | DP-10
Program for Fibonacci numbers
Longest Common Subsequence | DP-4
Bellman–Ford Algorithm | DP-23
Floyd Warshall Algorithm | DP-16