# Sum of products of all possible K size subsets of the given array

Given an array arr[] of N non-negative integers and an integer 1 ≤ K ≤ N. The task is to find the sum of the products of all possible subsets of arr[] of size K.

Examples:

Input: arr[] = {1, 2, 3, 4}, K = 2
Output: 35
(1 * 2) + (1 * 3) + (1 * 4) + (2 * 3) + (2 * 4)
+ (3 * 4) = 2 + 3 + 4 + 6 + 8 + 12 = 35

Input: arr[] = {1, 2, 3, 4}, K = 3
Output: 50

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive approach: Generate all possible subsets of size K and find the resultant product of each subset. Then sum the product obtained for each subset. The time complexity of this solution would be exponential.

Efficient approach: Take the example of an array a[] = {1, 2, 3} and K = 3. Then,

k = 1, answer = 1 + 2 + 3 = 6
k = 2, answer = 1 * (2 + 3) + 2 * 3 + 0 = 11
k = 3, answer = 1 * (2 * 3 + 0) + 0 + 0 = 6

In the example, if the contribution of 1 is needed to be obtained in the answer for K = 2 then the sum of all elements after the index of element 1 is required in the previously computed values for K = 1. It can be seen that the sum of elements 2 and 3 is required. Thus, for any K, the answer obtained for K – 1 is required.
So, bottom up dynamic programming approach can be used to solve this problem. Create a table dp[][] and fill it in bottom up manner where dp[i][j] will store the contribution of an element arr[j – 1] to the answer for K = i. Hence, the recurrence relation will be,

dp[i][j] = arr[i-1] * dp[i-1][k]

answer[k] = dp[k][i]

Below is the implementation of the above approach:

 // C++ implementation of the approach  #include  using namespace std;     // Function to return the sum of products of  // all the possible k size subsets  int sumOfProduct(int arr[], int n, int k)  {      // Initialising all the values to 0      int dp[n + 1][n + 1] = { 0 };         // To store the answer for      // current value of k      int cur_sum = 0;         // For k = 1, the answer will simply      // be the sum of all the elements      for (int i = 1; i <= n; i++) {          dp[i] = arr[i - 1];          cur_sum += arr[i - 1];      }         // Filling the table in bottom up manner      for (int i = 2; i <= k; i++) {             // To store the elements of the current          // row so that we will be able to use this sum          // for subsequent values of k          int temp_sum = 0;             for (int j = 1; j <= n; j++) {                 // We will subtract previously computed value              // so as to get the sum of elements from j + 1              // to n in the (i - 1)th row              cur_sum -= dp[i - 1][j];                 dp[i][j] = arr[j - 1] * cur_sum;              temp_sum += dp[i][j];          }          cur_sum = temp_sum;      }      return cur_sum;  }     // Driver code  int main()  {      int arr[] = { 1, 2, 3, 4 };      int n = sizeof(arr) / sizeof(int);      int k = 2;         cout << sumOfProduct(arr, n, k);         return 0;  }

Time Complexity: O(N2)

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.