Partition of a set into K subsets with equal sum

Last Updated : 26 Nov, 2024

Given an integer array arr[] and an integer k, the task is to check if it is possible to divide the given array into k non-empty subsets of equal sum such that every array element is part of a single subset.

Examples:

Input: arr[] = [2, 1, 4, 5, 6], k = 3
Output: true
Explanation: Possible subsets of the given array are [2, 4], [1, 5] and [6]
Input: arr[] = [2, 1, 5, 5, 6], k = 3
Output: false
Explanation: It is not possible to divide above array into 3 parts with equal sum.

Approach:

We can solve this problem recursively by exploring all possible combinations for each of the k subsets. This is achieved by tracking the sum of the current subset and using a boolean array (taken) to check if an element has already been included in a subset or not.
Base Cases:
if k = 1, the entire array forms the only subset.
if n < k, it is impossible to divide the array into k subset since there are not enough elements.
if the total sum of array is not divisible by k, equal partitioning is not feasible.
if these condition are met, the task reduces to dividing the array into k subsets , each with sum equal to arraySum/k.
Recursive Cases:
The recursive function attempts to add elements to each subset:
If a subset’s sum matches the required value, the function moves to the next subset.
If a subset doesn’t reach the target, the function backtracks and tries other combinations of elements.
Once k-1 subsets reach the required sum, the remaining elements automatically form the final subset with the desired sum, confirming that partitioning is possible.
This process continues until either all subsets are formed successfully or no valid partitioning is found.

C++

// C++ program to check whether an array can be // partitioned into K subsets of equal sum  #include <bits/stdc++.h> using namespace std;  bool isKPartitionPossible(vector<int> &arr, vector<int> &subsetSum,                           vector<bool> &taken, int target, int k,                           int n, int currIdx, int limitIdx) {      // If the current subset sum matches the target     if (subsetSum[currIdx] == target) {                // If all but one subset are filled, the         // last subset is guaranteed to work         if (currIdx == k - 2)             return true;         return isKPartitionPossible(arr, subsetSum, taken,                                     target, k, n, currIdx + 1, n - 1);     }      // Try including each element in the current subset     for (int i = limitIdx; i >= 0; i--) {                // Skip if the element is already used         if (taken[i])             continue;         int temp = subsetSum[currIdx] + arr[i];         if (temp <= target) {                        // Only proceed if it doesn't exceed the target             taken[i] = true;             subsetSum[currIdx] += arr[i];             if (isKPartitionPossible(arr, subsetSum, taken,                                      target, k, n, currIdx, i - 1))                 return true;              // Backtrack             taken[i] = false;             subsetSum[currIdx] -= arr[i];         }     }     return false; }  bool isKPartitionPossible(vector<int> &arr, int k) {        int n = arr.size(), sum = accumulate(arr.begin(), arr.end(), 0);      // If only one subset is needed, it's always possible     if (k == 1)         return true;      // Check if partition is impossible     if (n < k || sum % k != 0)         return false;      int target = sum / k;     vector<int> subsetSum(k, 0);     vector<bool> taken(n, false);      // Initialize first subset with the last element     subsetSum[0] = arr[n - 1];     taken[n - 1] = true;      // Recursively check for partitions     return isKPartitionPossible(arr, subsetSum, taken,                                 target, k, n, 0, n - 1); }  int main() {     vector<int> arr = {2, 1, 4, 5, 3, 3};     int k = 3;      if (isKPartitionPossible(arr, k))         cout << "true";     else         cout << "false";      return 0; }

Java

// Java program to check whether an array can be // partitioned into K subsets of equal sum  import java.util.Arrays;  class GfG {       static boolean     isKPartitionPossible(int[] arr, int[] subsetSum,                          boolean[] taken, int target, int k,                          int n, int currIdx, int limitIdx) {                // If the current subset sum matches the target         if (subsetSum[currIdx] == target) {                        // If all but one subset are filled, the last             // subset is guaranteed to work             if (currIdx == k - 2)                 return true;             return isKPartitionPossible(arr, subsetSum,                                         taken, target, k, n,                                         currIdx + 1, n - 1);         }          // Try including each element in the current subset         for (int i = limitIdx; i >= 0; i--) {             if (taken[i])                   continue;              int temp = subsetSum[currIdx] + arr[i];             if (temp                 <= target) {                                // Only proceed if it doesn't                // exceed the target                 taken[i] = true;                 subsetSum[currIdx] += arr[i];                  if (isKPartitionPossible(arr, subsetSum,                                          taken, target, k,                                          n, currIdx, i - 1))                     return true;                  // Backtrack                 taken[i] = false;                 subsetSum[currIdx] -= arr[i];             }         }         return false;     }        static boolean isKPartitionPossible(int[] arr, int k) {         int n = arr.length;         int sum = Arrays.stream(arr).sum();          // If only one subset is needed, it's always         // possible         if (k == 1)             return true;          // Check if partition is impossible         if (n < k || sum % k != 0)             return false;          int target = sum / k;         int[] subsetSum = new int[k];         boolean[] taken = new boolean[n];          // Initialize the first subset with the       	// last element         subsetSum[0] = arr[n - 1];         taken[n - 1] = true;          // Recursively check for partitions         return isKPartitionPossible(arr, subsetSum, taken,                                     target, k, n, 0, n - 1);     }      public static void main(String[] args) {         int[] arr = { 2, 1, 4, 5, 3, 3 };         int k = 3;          if (isKPartitionPossible(arr, k))             System.out.println("true");         else             System.out.println("false");     } }

Python

# Python3 program to check whether an array can be # partitioned into K subsets of equal sum   def isKPartitionPossible(arr, subsetSum, taken,\                          target, k, n, currIdx, limitIdx):        # If the current subset sum matches the target     if subsetSum[currIdx] == target:                # If all but one subset are filled, the last         # subset is guaranteed to work         if currIdx == k - 2:             return True         return isKPartitionPossible(arr, subsetSum, taken,\                                     target, k, n, currIdx + 1, n - 1)      # Try including each element in the current subset     for i in range(limitIdx, -1, -1):              # Skip if the element is already used         if taken[i]:                continue          temp = subsetSum[currIdx] + arr[i]                  # Only proceed if it doesn't exceed the target         if temp <= target:                taken[i] = True             subsetSum[currIdx] += arr[i]              if isKPartitionPossible(arr, subsetSum, taken,\                                     target, k, n, currIdx, i - 1):                 return True              # Backtrack             taken[i] = False             subsetSum[currIdx] -= arr[i]      return False   def isKPartitionPossibleMain(arr, k):     n = len(arr)     totalSum = sum(arr)      # If only one subset is needed, it's     # always possible     if k == 1:         return True      # Check if partition is impossible     if n < k or totalSum % k != 0:         return False      target = totalSum // k     subsetSum = [0] * k     taken = [False] * n      # Initialize the first subset with the      # last element     subsetSum[0] = arr[-1]     taken[-1] = True      # Recursively check for partitions     return isKPartitionPossible(arr, subsetSum, taken,\                                 target, k, n, 0, n - 1)    arr = [2, 1, 4, 5, 3, 3] k = 3  if isKPartitionPossibleMain(arr, k):     print("true") else:     print("false")

// C# program to check whether an array can be // partitioned into K subsets of equal sum  using System;  class GfG {     static bool     isKPartitionPossible(int[] arr, int[] subsetSum,                          bool[] taken, int target, int k,                          int n, int currIdx, int limitIdx) {          // If the current subset sum matches the target         if (subsetSum[currIdx] == target) {              // If all but one subset are filled, the last             // subset is guaranteed to work             if (currIdx == k - 2)                 return true;             return isKPartitionPossible(arr, subsetSum,                                         taken, target, k, n,                                         currIdx + 1, n - 1);         }          // Try including each element in the current subset         for (int i = limitIdx; i >= 0; i--) {              // Skip if the element is already used             if (taken[i])                 continue;              int temp = subsetSum[currIdx] + arr[i];             if (temp <= target) {                 taken[i] = true;                 subsetSum[currIdx] += arr[i];                  if (isKPartitionPossible(arr, subsetSum,                                          taken, target, k,                                          n, currIdx, i - 1))                     return true;                  // Backtrack                 taken[i] = false;                 subsetSum[currIdx] -= arr[i];             }         }         return false;     }      static bool isKPartitionPossibleMain(int[] arr, int k) {         int n = arr.Length;         int totalSum = 0;          // Calculate the sum of the array         foreach(var num in arr) { totalSum += num; }          // If only one subset is needed, it's always         // possible         if (k == 1)             return true;          // Check if partition is impossible         if (n < k || totalSum % k != 0)             return false;          int target = totalSum / k;         int[] subsetSum = new int[k];         bool[] taken = new bool[n];          // Initialize the first subset with the last element         subsetSum[0] = arr[n - 1];         taken[n - 1] = true;          // Recursively check for partitions         return isKPartitionPossible(arr, subsetSum, taken,                                     target, k, n, 0, n - 1);     }      static void Main() {         int[] arr = { 2, 1, 4, 5, 3, 3 };         int k = 3;          if (isKPartitionPossibleMain(arr, k))             Console.WriteLine("true");         else             Console.WriteLine("false");     } }

JavaScript

// JavaScript program to check whether an array can be // partitioned into K subsets of equal sum      function isKPartitionPossible(arr, subsetSum, taken, target,                               k, n, currIdx, limitIdx) {                                    // If the current subset sum matches the target     if (subsetSum[currIdx] === target) {              // If all but one subset are filled, the last subset         // is guaranteed to work         if (currIdx === k - 2) {             return true;         }         return isKPartitionPossible(arr, subsetSum, taken,                                     target, k, n,                                     currIdx + 1, n - 1);     }      // Try including each element in the current subset     for (let i = limitIdx; i >= 0; i--) {         if (taken[i])               continue;          let temp = subsetSum[currIdx] + arr[i];         if (temp <= target) {                           taken[i] = true;             subsetSum[currIdx] += arr[i];              if (isKPartitionPossible(arr, subsetSum, taken,                                      target, k, n, currIdx,                                      i - 1)) {                 return true;             }              // Backtrack             taken[i] = false;             subsetSum[currIdx] -= arr[i];         }     }     return false; }   function isKPartitionPossibleMain(arr, k) {     let n = arr.length;     let totalSum = arr.reduce((sum, num) => sum + num, 0);      // If only one subset is needed, it's always possible     if (k === 1)         return true;      // Check if partition is impossible     if (n < k || totalSum % k !== 0)         return false;      let target = totalSum / k;     let subsetSum = new Array(k).fill(0);     let taken = new Array(n).fill(false);      // Initialize the first subset with the last element     subsetSum[0] = arr[n - 1];     taken[n - 1] = true;      // Recursively check for partitions     return isKPartitionPossible(arr, subsetSum, taken,                                 target, k, n, 0, n - 1); }   let arr = [ 2, 1, 4, 5, 3, 3 ]; let k = 3;  if (isKPartitionPossibleMain(arr, k)) {     console.log("true"); } else {     console.log("false"); }

Output

true

Time Complexity: O(k*2^n) For each k subset, The algorithm checks all possible subsets of the array (which is 2^n).
Auxilary Space: O(n) where n is the length of array.

Related article:

Partition of a set into k subsets with equal sum using BitMask and DP

Longest Possible Route in a Matrix with Hurdles

kartik

Improve

Article Tags :

Practice Tags :

Partition of a set into K subsets with equal sum

Similar Reads

Standard problems on backtracking

Easy Problems on Backtracking

Medium prblems on Backtracking

Hard problems on Backtracking