GeeksforGeeks App
Open App
Browser
Continue

# Check if an array can be split into 3 subsequences of equal sum or not

Given an array arr[] having N integers. The task is to determine if the array can be partitioned into 3 subsequences of an 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 sum1, sum2, 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 ``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[0]);` `  ``// Function Call``  ``checkEqualSum(arr, N);``  ``return` `0;``}`

## Java

 `// Java program for``// the above approach``class` `GFG{` `// Utility function to check array can``// be partition to 3 subsequences of``// equal sum or not``static` `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` `Math.max(Math.max(l, m), r);``  ``}``}` `// Function to check array can be``// partition to 3 subsequences of``// equal sum or not``static` `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``)``  ``{``    ``System.out.print(``"Yes"``);``  ``}``  ``else``  ``{``    ``System.out.print(``"No"``);``  ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ``// Given array arr[]``  ``int` `arr[] = {``17``, ``34``, ``59``, ``23``, ``17``,``               ``67``, ``57``, ``2``, ``18``, ``59``, ``1``};       ` `  ``int` `N = arr.length;` `  ``// Function Call``  ``checkEqualSum(arr, N);``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program for the above approach` `# Utility function to check array can``# be partition to 3 subsequences of``# equal sum or not``def` `checkEqualSumUtil(arr, N, sm1, sm2, sm3, j):``    ` `    ``# Base case``    ``if` `j ``=``=` `N:``        ``if` `sm1 ``=``=` `sm2 ``and` `sm2 ``=``=` `sm3:``            ``return` `1``        ``else``:``            ``return` `0``    ``else``:``        ` `        ``# When element at index``        ``# j is added to sm1``        ``l ``=` `checkEqualSumUtil(arr, N, sm1 ``+` `arr[j],``                              ``sm2, sm3, j ``+` `1``)``        ` `        ``# When element at index``        ``# j is added to sm2``        ``m ``=` `checkEqualSumUtil(arr, N, sm1,``                              ``sm2 ``+` `arr[j],``                              ``sm3, j ``+` `1``)``        ` `        ``# When element at index``        ``# j is added to sm3``        ``r ``=` `checkEqualSumUtil(arr, N, sm1,``                              ``sm2, sm3 ``+` `arr[j],``                                     ``j ``+` `1``)``        ` `        ``# Return maximum value among``        ``# all above 3 recursive call``        ``return` `max``(l, m, r)``    ` `# Function to check array can be``# partition to 3 subsequences of``# equal sum or not``def` `checkEqualSum(arr, N):``    ` `    ``# Initialise 3 sums to 0``    ``sum1 ``=` `sum2 ``=` `sum3 ``=` `0``    ` `    ``# Function call``    ``if` `checkEqualSumUtil(arr, N, sum1,``                         ``sum2, sum3, ``0``) ``=``=` `1``:``        ``print``(``"Yes"``)``    ``else``:``        ``print``(``"No"``)``    ` `# Driver code``    ` `# Given array arr[]``arr ``=` `[ ``17``, ``34``, ``59``, ``23``, ``17``,``        ``67``, ``57``, ``2``, ``18``, ``59``, ``1` `]``N ``=` `len``(arr)` `# Function call``checkEqualSum(arr, N)` `# This code is contributed by Stuti Pathak`

## C#

 `// C# program for``// the above approach``using` `System;``class` `GFG{` `// Utility function to check array can``// be partition to 3 subsequences of``// equal sum or not``static` `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` `Math.Max(Math.Max(l, m), r);``  ``}``}` `// Function to check array can be``// partition to 3 subsequences of``// equal sum or not``static` `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)``  ``{``    ``Console.Write(``"Yes"``);``  ``}``  ``else``  ``{``    ``Console.Write(``"No"``);``  ``}``}` `// Driver Code``public` `static` `void` `Main()``{``  ``// Given array arr[]``  ``int``[] arr = {17, 34, 59, 23, 17,``               ``67, 57, 2, 18, 59, 1};``  ``int` `N = arr.Length;` `  ``// Function Call``  ``checkEqualSum(arr, N);``}``}` `// This code is contributed by Chitranayal`

## Javascript

 ``

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:

• Let sum1, sum2, and sum3 be the three equal sum to be partitioned.
• Create a map dp having the key.
• 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 sum1, sum2, and sum3 are equal then return 1 that will ensure that we can break the given array into a subsequence of equal sum value. Otherwise, return 0.
• Recursive Call: For each element in the array include each element in sum1, sum2, and sum3 one by one and return the maximum of these recursive calls.

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(sum2) + to_string(j)
return dp[s] = max(a, max(b, c) )

• 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 ``using` `namespace` `std;``map 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[0]);` `    ``// Function Call``    ``checkEqualSum(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for``// the above approach``import` `java.util.*;``class` `GFG{``static` `HashMap dp = ``new` `HashMap();` `// Function to check array can be``// partition into sum of 3 equal``static` `int` `checkEqualSumUtil(``int` `arr[], ``int` `N,``                             ``int` `sm1, ``int` `sm2,``                             ``int` `sm3, ``int` `j)``{``  ``String s = String.valueOf(sm1) + ``"_"` `+``  ``String.valueOf(sm2) + String.valueOf(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.containsKey(s))``    ``return` `dp.get(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``    ``dp.put(s, Math.max(Math.max(l, m), r));``    ``return` `dp.get(s);``  ``}``}` `// Function to check array can be``// partition to 3 subsequences of``// equal sum or not``static` `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``)``  ``{``    ``System.out.print(``"Yes"``);``  ``}``  ``else``  ``{``    ``System.out.print(``"No"``);``  ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ``// Given array arr[]``  ``int` `arr[] = {``17``, ``34``, ``59``, ``23``, ``17``,``               ``67``, ``57``, ``2``, ``18``, ``59``, ``1``};` `  ``int` `N = arr.length;` `  ``// Function Call``  ``checkEqualSum(arr, N);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program for the above approach``dp ``=` `{}` `# Function to check array can be``# partition into sum of 3 equal``def` `checkEqualSumUtil(arr, N, sm1, sm2, sm3, j):``    ` `    ``s ``=` `str``(sm1) ``+` `"_"` `+` `str``(sm2) ``+` `str``(j)``    ` `    ``# Base Case``    ``if` `j ``=``=` `N:``        ``if` `sm1 ``=``=` `sm2 ``and` `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` `s ``in` `dp:``        ``return` `dp[s]``    ` `    ``# When element at index``    ``# j is added to sm1``    ``l ``=` `checkEqualSumUtil(arr, N, sm1 ``+` `arr[j],``                          ``sm2, sm3, j ``+` `1``)``    ` `    ``# When element at index``    ``# j is added to sm2``    ``m ``=` `checkEqualSumUtil(arr, N, sm1,``                          ``sm2 ``+` `arr[j], sm3,``                            ``j ``+` `1``)``    ` `    ``# When element at index``    ``# j is added to sm3``    ``r ``=` `checkEqualSumUtil(arr, N, sm1,``                          ``sm2, sm3 ``+` `arr[j],``                                 ``j ``+` `1``)``    ` `    ``# Update the current state and``    ``# return that value``    ``dp[s] ``=` `max``(l, m, r)``    ` `    ``return` `dp[s]` `# Function to check array can be``# partition to 3 subsequences of``# equal sum or not``def` `checkEqualSum(arr, N):``    ` `    ``# Initialise 3 sums to 0``    ``sum1 ``=` `sum2 ``=` `sum3 ``=` `0``    ` `    ``# Function Call``    ``if` `checkEqualSumUtil(arr, N, sum1,``                         ``sum2, sum3, ``0``) ``=``=` `1``:``        ``print``(``"Yes"``)``    ``else``:``        ``print``(``"No"``)``        ` `# Driver code` `# Given array arr[]``arr ``=` `[ ``17``, ``34``, ``59``, ``23``, ``17``,``        ``67``, ``57``, ``2``, ``18``, ``59``, ``1` `]``N ``=` `len``(arr)` `# Function call``checkEqualSum(arr, N)` `# This code is contributed by Stuti Pathak`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{``    ` `static` `Dictionary<``string``,``                  ``int``> dp = ``new` `Dictionary<``string``,``                                           ``int``>();`` ` `// Function to check array can be``// partition into sum of 3 equal``static` `int` `checkEqualSumUtil(``int` `[]arr, ``int` `N,``                             ``int` `sm1, ``int` `sm2,``                             ``int` `sm3, ``int` `j)``{``    ``string` `s = sm1.ToString() + ``"_"` `+``               ``sm2.ToString() + j.ToString();``    ` `    ``// 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.ContainsKey(s))``        ``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``        ``dp[s] = Math.Max(Math.Max(l, m), r);``        ` `        ``return` `dp[s];``    ``}``}`` ` `// Function to check array can be``// partition to 3 subsequences of``// equal sum or not``static` `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)``    ``{``        ``Console.Write(``"Yes"``);``    ``}``    ``else``    ``{``        ``Console.Write(``"No"``);``    ``}``}`` ` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ` `    ``// Given array arr[]``    ``int` `[]arr = { 17, 34, 59, 23, 17,``                  ``67, 57, 2, 18, 59, 1 };``    ` `    ``int` `N = arr.Length;``    ` `    ``// Function call``    ``checkEqualSum(arr, N);``}``}` `// This code is contributed by rutvik_56`

## Javascript

 ``

Output:

`Yes`

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

(to_string(sum1) + “_” + to_string(sum2) + “_” + to_string(sum3))

• with value is 1 if 3 equal subsets are found else value is 0.

My Personal Notes arrow_drop_up