# Number of ways to divide an array into K equal sum sub-arrays

Given an integer K and an array arr[] of N integers, the task is to find the number of ways to split the array into K equal sum sub-arrays of non-zero lengths.

Examples:

Input: arr[] = {0, 0, 0, 0}, K = 3
Output: 3
All possible ways are:
{{0}, {0}, {0, 0}}
{{0}, {0, 0}, {0}}
{{0, 0}, {0}, {0}}

Input: arr[] = {1, -1, 1, -1}, K = 2
Output: 1

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

Approach: This problem can be solved using dynamic programming. Following will be our algorithm:

1. Find the sum of all the elements of the array and store it in a variable SUM.
Before going to step 2, let’s try and understand the states of the DP.
For that, visualize putting bars to divide array into K equal parts. So, we have to put K – 1 bars in total.
Thus, our states of dp will contain 2 terms.

• i – index of the element we are currently upon.
• ck – number of bars we have already inserted + 1.

dp[i][ck] can be defined as number of ways to put the remaining bars into the array such that it gets divided into K equal halves. Now, lets proceed to step 2 of our algorithm.

2. Call a recursive function with i = 0 and ck = 1 and the recurrence relation will be:

Case 1: sum upto index i equals ((SUM)/k)* ck
dp[i][ck] = dp[i+1][ck] + dp[i+1][ck+1]
Case 2: sum upto index not i equals ((SUM)/k)* ck
dp[i][ck] = dp[i+1][ck]

Below is the implementation of the above approach:

## C++

 // C++ implementation of the approach #include #define max_size 20 #define max_k 20 using namespace std;    // Array to store the states of DP int dp[max_size][max_k];    // Array to check if a // state has been solved before bool v[max_size][max_k];    // To store the sum of // the array elements int sum = 0;    // Function to find the sum of // all the array elements void findSum(int arr[], int n) {     for (int i = 0; i < n; i++)         sum += arr[i]; }    // Function to return the number of ways int cntWays(int arr[], int i, int ck,             int k, int n, int curr_sum) {     // If sum is not divisible by k     // answer will be zero     if (sum % k != 0)         return 0;     if (i != n and ck == k + 1)         return 0;        // Base case     if (i == n) {         if (ck == k + 1)             return 1;         else             return 0;     }        // To check if a state     // has been solved before     if (v[i][ck])         return dp[i][ck];        // Sum of all the numbers from the beginning     // of the array     curr_sum += arr[i];        // Setting the current state as solved     v[i][ck] = 1;        // Recurrence relation     dp[i][ck] = cntWays(arr, i + 1, ck, k, n, curr_sum);     if (curr_sum == (sum / k) * ck)         dp[i][ck] += cntWays(arr, i + 1, ck + 1, k, n, curr_sum);        // Returning solved state     return dp[i][ck]; }    // Driver code int main() {     int arr[] = { 1, -1, 1, -1, 1, -1 };     int n = sizeof(arr) / sizeof(int);     int k = 2;        // Function call to find the     // sum of the array elements     findSum(arr, n);        // Print the number of ways     cout << cntWays(arr, 0, 1, k, n, 0); }

## Java

 // Java implementation of the approach class GFG  {        static int max_size= 20; static int max_k =20;    // Array to store the states of DP static int [][]dp = new int[max_size][max_k];    // Array to check if a // state has been solved before static boolean [][]v = new boolean[max_size][max_k];    // To store the sum of // the array elements static int sum = 0;    // Function to find the sum of // all the array elements static void findSum(int arr[], int n) {     for (int i = 0; i < n; i++)         sum += arr[i]; }    // Function to return the number of ways static int cntWays(int arr[], int i, int ck,             int k, int n, int curr_sum) {     // If sum is not divisible by k     // answer will be zero     if (sum % k != 0)         return 0;     if (i != n && ck == k + 1)         return 0;        // Base case     if (i == n)      {         if (ck == k + 1)             return 1;         else             return 0;     }        // To check if a state     // has been solved before     if (v[i][ck])         return dp[i][ck];        // Sum of all the numbers from the beginning     // of the array     curr_sum += arr[i];        // Setting the current state as solved     v[i][ck] = true;        // Recurrence relation     dp[i][ck] = cntWays(arr, i + 1, ck, k, n, curr_sum);     if (curr_sum == (sum / k) * ck)         dp[i][ck] += cntWays(arr, i + 1, ck + 1, k, n, curr_sum);        // Returning solved state     return dp[i][ck]; }    // Driver code public static void main(String[] args) {     int arr[] = { 1, -1, 1, -1, 1, -1 };     int n = arr.length;     int k = 2;        // Function call to find the     // sum of the array elements     findSum(arr, n);        // Print the number of ways     System.out.println(cntWays(arr, 0, 1, k, n, 0)); } }    // This code is contributed by Princi Singh

## Python3

 # Python3 implementation of the approach import numpy as np    max_size = 20  max_k = 20        # Array to store the states of DP  dp = np.zeros((max_size,max_k));     # Array to check if a  # state has been solved before  v = np.zeros((max_size,max_k));     # To store the sum of  # the array elements  sum = 0;     # Function to find the sum of  # all the array elements  def findSum(arr, n) :      global sum     for i in range(n) :         sum += arr[i];        # Function to return the number of ways  def cntWays(arr, i, ck, k, n,  curr_sum) :         # If sum is not divisible by k      # answer will be zero      if (sum % k != 0) :         return 0;      if (i != n and ck == k + 1) :         return 0;         # Base case      if (i == n) :         if (ck == k + 1) :             return 1;          else :             return 0;         # To check if a state      # has been solved before      if (v[i][ck]) :         return dp[i][ck];         # Sum of all the numbers from the beginning      # of the array      curr_sum += arr[i];         # Setting the current state as solved      v[i][ck] = 1;         # Recurrence relation      dp[i][ck] = cntWays(arr, i + 1, ck, k, n, curr_sum);      if (curr_sum == (sum / k) * ck)  :         dp[i][ck] += cntWays(arr, i + 1, ck + 1, k, n, curr_sum);         # Returning solved state      return dp[i][ck];         # Driver code  if __name__ == "__main__" :         arr = [ 1, -1, 1, -1, 1, -1 ];      n = len(arr);      k = 2;         # Function call to find the      # sum of the array elements      findSum(arr, n);         # Print the number of ways      print(cntWays(arr, 0, 1, k, n, 0));         # This code is contributed by AnkitRai01

## C#

 // C# implementation of the approach using System;             class GFG  {        static int max_size= 20; static int max_k =20;    // Array to store the states of DP static int [,]dp = new int[max_size, max_k];    // Array to check if a // state has been solved before static Boolean [,]v = new Boolean[max_size, max_k];    // To store the sum of // the array elements static int sum = 0;    // Function to find the sum of // all the array elements static void findSum(int []arr, int n) {     for (int i = 0; i < n; i++)         sum += arr[i]; }    // Function to return the number of ways static int cntWays(int []arr, int i, int ck,             int k, int n, int curr_sum) {     // If sum is not divisible by k     // answer will be zero     if (sum % k != 0)         return 0;     if (i != n && ck == k + 1)         return 0;        // Base case     if (i == n)      {         if (ck == k + 1)             return 1;         else             return 0;     }        // To check if a state     // has been solved before     if (v[i, ck])         return dp[i, ck];        // Sum of all the numbers from the beginning     // of the array     curr_sum += arr[i];        // Setting the current state as solved     v[i, ck] = true;        // Recurrence relation     dp[i,ck] = cntWays(arr, i + 1, ck, k, n, curr_sum);     if (curr_sum == (sum / k) * ck)         dp[i, ck] += cntWays(arr, i + 1, ck + 1, k, n, curr_sum);        // Returning solved state     return dp[i, ck]; }    // Driver code public static void Main(String[] args) {     int []arr = { 1, -1, 1, -1, 1, -1 };     int n = arr.Length;     int k = 2;        // Function call to find the     // sum of the array elements     findSum(arr, n);        // Print the number of ways     Console.WriteLine(cntWays(arr, 0, 1, k, n, 0)); } }    // This code contributed by Rajput-Ji

Output:

2

Time Complexity: O(n*k)

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.