# Check if an array can be split into 3 subsequences of equal sum or not A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

Given an array arr[] having N integers. The task is to determine if the array can be partitioned into 3 subsequences of equal sum or not. If yes then print “Yes”. Otherwise, print “No”.

Examples:

Input:_ arr[] = {1, 1, 1}_

Output:_ Yes_

Explanation:

_Here array can be partition into 3 equal sum. {1}  _

Input:_ arr[] = {40}_

Output:_ No_

Explanation:

Here array cannot be partition into 3 equal sum.

Recursive Approach: This problem can be solved using recursion. Below are the steps:

1. Initialize three variable sum1sum2, and sum3 to value 0.
2. Then every element of array arr[] is added to either of these 3 variables, which give all the possible combinations.
3. In case, any subsequences having 3 equal sums then the array can be partition.
4. If the array can be partition then print “Yes” else print “No”.
• C++

`// C++ program for the above approach`

`#include <bits/stdc++.h>`

`**using**` `**namespace**` `std;`

`// Utility function to check array can`

`// be partition to 3 subsequences of`

`// equal sum or not`

`**int**` `checkEqualSumUtil(``**int**` `arr[],` `**int**` `N,`

`**int**` `sm1,` `**int**` `sm2,`

`**int**` `sm3,` `**int**` `j)`

`{`

`// Base Case`

`**if**` `(j == N) {`

`**if**` `(sm1 == sm2 && sm2 == sm3)`

`**return**` `1;`

`**else**`

`**return**` `0;`

`}`

`**else**` `{`

`// When element at index`

`// j is added to sm1`

`**int**` `l = checkEqualSumUtil(`

`arr, N,`

`sm1 + arr[j], sm2,`

`sm3, j + 1);`

`// When element at index`

`// j is added to sm2`

`**int**` `m = checkEqualSumUtil(`

`arr, N, sm1,`

`sm2 + arr[j],`

`sm3, j + 1);`

`// When element at index`

`// j is added to sm3`

`**int**` `r = checkEqualSumUtil(`

`arr, N, sm1, sm2,`

`sm3 + arr[j], j + 1);`

`// Return maximum value among`

`// all above 3 recursive call`

`**return**` `max(max(l, m), r);`

`}`

`}`

`// Function to check array can be`

`// partition to 3 subsequences of`

`// equal sum or not`

`**void**` `checkEqualSum(``**int**` `arr[],` `**int**` `N)`

`{`

`// Initialise 3 sums to 0`

`**int**` `sum1, sum2, sum3;`

`sum1 = sum2 = sum3 = 0;`

`// Function Call`

`**if**` `(checkEqualSumUtil(`

`arr, N, sum1,`

`sum2, sum3, 0)`

`== 1) {`

`cout <<` `"Yes"``;`

`}`

`**else**` `{`

`cout <<` `"No"``;`

`}`

`}`

`// Driver Code`

`**int**` `main()`

`{`

`// Given array arr[]`

`**int**` `arr[]`

`= { 17, 34, 59, 23, 17, 67,`

`57, 2, 18, 59, 1 };`

`**int**` `N =` `**sizeof**``(arr) /` `**sizeof**``(arr);`

`// Function Call`

`checkEqualSum(arr, N);`

`**return**` `0;`

`}`

Output:

``Yes``

Time Complexity:_ O(3N)_

Auxiliary Space:_ O(1)_

Dynamic Programming** Approach:** This problem can be solved using dynamic programming, the idea is to store all the overlapping subproblems value in a map and use the value of overlapping substructure to reduce the number of the recursive calls. Below are the steps:

1. Let sum1sum2, and sum3 be the three equal sum to be partitioned.
2. Create a map dp having the key:

(to_string(sum1) + “_” + _**_to_string_(sum2) + “_” + _to_string**(sum3))

1. with value is 1 if 3 equal subsets are found else value is 0.
2. Traverse the given array and do the following:
• Base Case: While traversing the array if we reach the end of the array then check if the value of sum1sum2, and sum3 are equal then return 1 that will ensure that we can break the given array into subsequence of equal sum value. Otherwise return 0.
• Recursive Call: For each element in the array include each element in sum1sum2, and sum3 one by one and return the maximum of the these recursive call.

a = recursive_function(arr, N, sum1 + arr[j], sum2, sum3, j + 1)

b = recursive_function(arr, N, sum1, sum2 + arr[j], sum3, j + 1)

c = recursive_function(arr, N, sum1, sum2, sum3 + arr[j], j + 1)

• Return Statement: In the above recursive call the maximum of the three values will give the result for the current recursive call. Update the current state in the dp table as:

string s = to_string(sum1) + ‘_’ + to_string(sum1) + to_string(sum1)

return dp[s] = max(a, max(b, c)

1. If there can be partition possible then print “Yes” else print “No”.

Below is the implementation of the above approach:

• C++

`// C++ program for the above approach`

`#include <bits/stdc++.h>`

`**using**` `**namespace**` `std;`

`map<string,` `**int**``> dp;`

`// Function to check array can be`

`// partition into sum of 3 equal`

`**int**` `checkEqualSumUtil(``**int**` `arr[],` `**int**` `N,`

`**int**` `sm1,`

`**int**` `sm2,`

`**int**` `sm3,` `**int**` `j)`

`{`

`string s = to_string(sm1)`

`+` `"_"` `+ to_string(sm2)`

`+ to_string(j);`

`// Base Case`

`**if**` `(j == N) {`

`**if**` `(sm1 == sm2 && sm2 == sm3)`

`**return**` `1;`

`**else**`

`**return**` `0;`

`}`

`// If value at particular index is not`

`// -1 then return value at that index`

`// which ensure no more further calls`

`**if**` `(dp.find(s) != dp.end())`

`**return**` `dp[s];`

`**else**` `{`

`// When element at index`

`// j is added to sm1`

`**int**` `l = checkEqualSumUtil(`

`arr, N, sm1 + arr[j],`

`sm2, sm3, j + 1);`

`// When element at index`

`// j is added to sm2`

`**int**` `m = checkEqualSumUtil(`

`arr, N, sm1, sm2 + arr[j],`

`sm3, j + 1);`

`// When element at index`

`// j is added to sm3`

`**int**` `r = checkEqualSumUtil(`

`arr, N, sm1, sm2,`

`sm3 + arr[j], j + 1);`

`// Update the current state and`

`// return that value`

`**return**` `dp[s] = max(max(l, m), r);`

`}`

`}`

`// Function to check array can be`

`// partition to 3 subsequences of`

`// equal sum or not`

`**void**` `checkEqualSum(``**int**` `arr[],` `**int**` `N)`

`{`

`// Initialise 3 sums to 0`

`**int**` `sum1, sum2, sum3;`

`sum1 = sum2 = sum3 = 0;`

`// Function Call`

`**if**` `(checkEqualSumUtil(`

`arr, N, sum1,`

`sum2, sum3, 0)`

`== 1) {`

`cout <<` `"Yes"``;`

`}`

`**else**` `{`

`cout <<` `"No"``;`

`}`

`}`

`// Driver Code`

`**int**` `main()`

`{`

`// Given array arr[]`

`**int**` `arr[]`

`= { 17, 34, 59, 23, 17, 67,`

`57, 2, 18, 59, 1 };`

`**int**` `N =` `**sizeof**``(arr) /` `**sizeof**``(arr);`

`// Function Call`

`checkEqualSum(arr, N);`

`**return**` `0;`

`}`

Output:

``Yes``

Time Complexity:_ O(N*K2) _

Auxiliary Space:_ O(N*K2) where K is the sum of the array._

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.

## Maximize the Sum of a Subsequence from an Array based on given conditions

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

## Minimum length of subsequence having unit GCD

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

## All You Need to Know About Dynamic Programming

In this article, I will introduce the concept of dynamic programming, developed by Richard Bellman in the 1950s, a powerful algorithm design technique to solve problems by breaking them down into smaller

## While You Don't Understand Recursion, Read Recursion: by Randy Taylor

Recursion is the one idea I constantly use while I solve coding problems. Most of the time I don’t start by thinking “RECURSION WILL SOLVE THIS!”. However recursion just ends up being the logical way to reach an answer.

## Maximum subsequence sum obtained by concatenating disjoint subarrays

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.