Count ways to split array into K non-intersecting subsets

Given an array, arr[] of size N and an integer K, the task is to split the array into K non-intersecting subsets such that union of all the K subsets is equal to the given array.

Examples:

Input : arr[]= {2, 3},  K=2
Output: 4
Explanations:
Possible ways to partition the array into K(=2) subsets are:{ {{}, {2, 3}}, {{2}, {3}}, {{3}, {2}}, {{2, 3}, {}} }. 
Therefore, the required output is 4.

 Input: arr[] = {2, 2, 3, 3}, K = 3
Output: 9

Approach: The problem can be solved based on the following observations:



The total number of ways to place an element into any one of the K subsets = K. 
Therefore, the total number of ways to place all distinct elements of the given array into K subsets = K × K × …..× K(M times) = KM 
Where M = total number of distinct elements in the given array.

Follow the steps below to solve the problem:

Below is the implementation of the above approach: 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to get
// the value of pow(K, M)
int power(int K, int M)
{
    // Stores value of pow(K, M)
    int res = 1;
 
    // Calculate value of pow(K, N)
    while (M > 0) {
 
        // If N is odd, update
        // res
        if ((M & 1) == 1) {
            res = (res * K);
        }
 
        // Update M to M / 2
        M = M >> 1;
 
        // Update K
        K = (K * K);
    }
    return res;
}
 
// Function to print total ways
// to split the array that
// satisfies the given condition
int cntWays(int arr[], int N,
            int K)
{
    // Stores total ways that
    // satisfies the given
    // condition
    int cntways = 0;
 
    // Stores count of distinct
    // elements in the given arr
    int M = 0;
 
    // Store distinct elements
    // of the given array
    unordered_set<int> st;
 
    // Traverse the given array
    for (int i = 0; i < N; i++) {
 
        // Insert current element
        // into set st.
        st.insert(arr[i]);
    }
 
    // Update M
    M = st.size();
 
    // Update cntways
    cntways = power(K, M);
 
    return cntways;
}
 
// Driver Code
int main()
{
 
    int arr[] = { 2, 3 };
    int N = sizeof(arr) / sizeof(arr[0]);
    int K = 2;
    cout << cntWays(arr, N, K);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement
// the above approach
import java.io.*;
import java.util.*;
 
class GFG{
     
// Function to get
// the value of pow(K, M)
static int power(int K, int M)
{
     
    // Stores value of pow(K, M)
    int res = 1;
  
    // Calculate value of pow(K, N)
    while (M > 0)
    {
         
        // If N is odd, update
        // res
        if ((M & 1) == 1)
        {
            res = (res * K);
        }
  
        // Update M to M / 2
        M = M >> 1;
  
        // Update K
        K = (K * K);
    }
    return res;
}
  
// Function to print total ways
// to split the array that
// satisfies the given condition
static int cntWays(int arr[], int N,
                   int K)
{
     
    // Stores total ways that
    // satisfies the given
    // condition
    int cntways = 0;
  
    // Stores count of distinct
    // elements in the given arr
    int M = 0;
  
    // Store distinct elements
    // of the given array
    Set<Integer> st = new HashSet<Integer>(); 
     
    // Traverse the given array
    for(int i = 0; i < N; i++)
    {
  
        // Insert current element
        // into set st.
        st.add(arr[i]);
    }
  
    // Update M
    M = st.size();
  
    // Update cntways
    cntways = power(K, M);
  
    return cntways;
}
  
// Driver Code
public static void main (String[] args)
{
    int arr[] = { 2, 3 };
    int N = arr.length;
    int K = 2;
     
    System.out.println(cntWays(arr, N, K));
}
}
 
// This code is contributed by sanjoy_62

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to implement
# the above approach
 
# Function to get
# the value of pow(K, M)
def power(K, M):
 
    # Stores value of pow(K, M)
    res = 1
 
    # Calculate value of pow(K, N)
    while (M > 0):
 
        # If N is odd, update
        # res
        if ((M & 1) == 1):
            res = (res * K)
 
        # Update M to M / 2
        M = M >> 1
 
        # Update K
        K = (K * K)
    
    return res
 
# Function to print total ways
# to split the array that
# satisfies the given condition
def cntWays(arr, N, K):
     
    # Stores total ways that
    # satisfies the given
    # condition
    cntways = 0
 
    # Stores count of distinct
    # elements in the given arr
    M = 0
 
    # Store distinct elements
    # of the given array
    st = set()
 
    # Traverse the given array
    for i in range(N):
         
        # Insert current element
        # into set st.
        st.add(arr[i])
    
    # Update M
    M = len(st)
 
    # Update cntways
    cntways = power(K, M)
 
    return cntways
 
# Driver Code
if __name__ == '__main__':
  
    arr = [ 2, 3 ]
    N = len(arr)
    K = 2
      
    print(cntWays(arr, N, K))
 
# This code is contributed by math_lover

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to implement
// the above approach 
using System;
using System.Collections.Generic;
 
class GFG{
      
// Function to get
// the value of pow(K, M)
static int power(int K, int M)
{
     
    // Stores value of pow(K, M)
    int res = 1;
   
    // Calculate value of pow(K, N)
    while (M > 0)
    {
         
        // If N is odd, update
        // res
        if ((M & 1) == 1)
        {
            res = (res * K);
        }
   
        // Update M to M / 2
        M = M >> 1;
   
        // Update K
        K = (K * K);
    }
    return res;
}
   
// Function to print total ways
// to split the array that
// satisfies the given condition
static int cntWays(int[] arr, int N,
                   int K)
{
     
    // Stores total ways that
    // satisfies the given
    // condition
    int cntways = 0;
   
    // Stores count of distinct
    // elements in the given arr
    int M = 0;
   
    // Store distinct elements
    // of the given array
    HashSet<int> st = new HashSet<int>();
     
    // Traverse the given array
    for(int i = 0; i < N; i++)
    {
         
        // Insert current element
        // into set st.
        st.Add(arr[i]);
    }
   
    // Update M
    M = st.Count;
   
    // Update cntways
    cntways = power(K, M);
   
    return cntways;
}
  
// Driver code
public static void Main()
{
    int[] arr = { 2, 3 };
    int N = arr.Length;
    int K = 2;
      
    Console.WriteLine(cntWays(arr, N, K));
}
}
 
// This code is contributed by code_hunt

chevron_right


Output: 

4











 

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

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.




My Personal Notes arrow_drop_up

Recommended Posts:


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.