Check if an array can be split into 3 subsequences of equal sum or not
Last Updated :
14 Jun, 2021
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:
- Initialize three variable sum1, sum2, and sum3 to value 0.
- Then every element of array arr[] is added to either of these 3 variables, which give all the possible combinations.
- In case, any subsequences having 3 equal sums then the array can be partition.
- If the array can be partition then print “Yes” else print “No”.
C++
#include <bits/stdc++.h>
using namespace std;
int checkEqualSumUtil( int arr[], int N,
int sm1, int sm2,
int sm3, int j)
{
if (j == N)
{
if (sm1 == sm2 && sm2 == sm3)
return 1;
else
return 0;
}
else
{
int l = checkEqualSumUtil(arr, N,
sm1 + arr[j],
sm2, sm3, j + 1);
int m = checkEqualSumUtil(arr, N, sm1,
sm2 + arr[j],
sm3, j + 1);
int r = checkEqualSumUtil(arr, N, sm1, sm2,
sm3 + arr[j], j + 1);
return max(max(l, m), r);
}
}
void checkEqualSum( int arr[], int N)
{
int sum1, sum2, sum3;
sum1 = sum2 = sum3 = 0;
if (checkEqualSumUtil(arr, N, sum1,
sum2, sum3, 0)== 1)
{
cout << "Yes" ;
}
else
{
cout << "No" ;
}
}
int main()
{
int arr[] = {17, 34, 59, 23, 17, 67,
57, 2, 18, 59, 1 };
int N = sizeof (arr) / sizeof (arr[0]);
checkEqualSum(arr, N);
return 0;
}
|
Java
class GFG{
static int checkEqualSumUtil( int arr[], int N,
int sm1, int sm2,
int sm3, int j)
{
if (j == N)
{
if (sm1 == sm2 && sm2 == sm3)
return 1 ;
else
return 0 ;
}
else
{
int l = checkEqualSumUtil(arr, N,
sm1 + arr[j],
sm2, sm3, j + 1 );
int m = checkEqualSumUtil(arr, N, sm1,
sm2 + arr[j],
sm3, j + 1 );
int r = checkEqualSumUtil(arr, N, sm1, sm2,
sm3 + arr[j], j + 1 );
return Math.max(Math.max(l, m), r);
}
}
static void checkEqualSum( int arr[], int N)
{
int sum1, sum2, sum3;
sum1 = sum2 = sum3 = 0 ;
if (checkEqualSumUtil(arr, N, sum1,
sum2, sum3, 0 ) == 1 )
{
System.out.print( "Yes" );
}
else
{
System.out.print( "No" );
}
}
public static void main(String[] args)
{
int arr[] = { 17 , 34 , 59 , 23 , 17 ,
67 , 57 , 2 , 18 , 59 , 1 };
int N = arr.length;
checkEqualSum(arr, N);
}
}
|
Python3
def checkEqualSumUtil(arr, N, sm1, sm2, sm3, j):
if j = = N:
if sm1 = = sm2 and sm2 = = sm3:
return 1
else :
return 0
else :
l = checkEqualSumUtil(arr, N, sm1 + arr[j],
sm2, sm3, j + 1 )
m = checkEqualSumUtil(arr, N, sm1,
sm2 + arr[j],
sm3, j + 1 )
r = checkEqualSumUtil(arr, N, sm1,
sm2, sm3 + arr[j],
j + 1 )
return max (l, m, r)
def checkEqualSum(arr, N):
sum1 = sum2 = sum3 = 0
if checkEqualSumUtil(arr, N, sum1,
sum2, sum3, 0 ) = = 1 :
print ( "Yes" )
else :
print ( "No" )
arr = [ 17 , 34 , 59 , 23 , 17 ,
67 , 57 , 2 , 18 , 59 , 1 ]
N = len (arr)
checkEqualSum(arr, N)
|
C#
using System;
class GFG{
static int checkEqualSumUtil( int [] arr, int N,
int sm1, int sm2,
int sm3, int j)
{
if (j == N)
{
if (sm1 == sm2 && sm2 == sm3)
return 1;
else
return 0;
}
else
{
int l = checkEqualSumUtil(arr, N,
sm1 + arr[j],
sm2, sm3, j + 1);
int m = checkEqualSumUtil(arr, N, sm1,
sm2 + arr[j],
sm3, j + 1);
int r = checkEqualSumUtil(arr, N,
sm1, sm2,
sm3 + arr[j],
j + 1);
return Math.Max(Math.Max(l, m), r);
}
}
static void checkEqualSum( int [] arr, int N)
{
int sum1, sum2, sum3;
sum1 = sum2 = sum3 = 0;
if (checkEqualSumUtil(arr, N, sum1,
sum2, sum3, 0) == 1)
{
Console.Write( "Yes" );
}
else
{
Console.Write( "No" );
}
}
public static void Main()
{
int [] arr = {17, 34, 59, 23, 17,
67, 57, 2, 18, 59, 1};
int N = arr.Length;
checkEqualSum(arr, N);
}
}
|
Javascript
<script>
function checkEqualSumUtil( arr, N,
sm1, sm2,
sm3, j)
{
if (j == N)
{
if (sm1 == sm2 && sm2 == sm3)
return 1;
else
return 0;
}
else
{
let l = checkEqualSumUtil(arr, N,
sm1 + arr[j],
sm2, sm3, j + 1);
let m = checkEqualSumUtil(arr, N, sm1,
sm2 + arr[j],
sm3, j + 1);
let r = checkEqualSumUtil(arr, N, sm1, sm2,
sm3 + arr[j], j + 1);
return Math.max(Math.max(l, m), r);
}
}
function checkEqualSum(arr,N)
{
let sum1, sum2, sum3;
sum1 = sum2 = sum3 = 0;
if (checkEqualSumUtil(arr, N, sum1,
sum2, sum3, 0) == 1)
{
document.write( "Yes" );
}
else
{
document.write( "No" );
}
}
let arr = [17, 34, 59, 23, 17,
67, 57, 2, 18, 59, 1];
let N = arr.length;
checkEqualSum(arr, N);
</script>
|
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++
#include <bits/stdc++.h>
using namespace std;
map<string, int > dp;
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);
if (j == N) {
if (sm1 == sm2 && sm2 == sm3)
return 1;
else
return 0;
}
if (dp.find(s) != dp.end())
return dp[s];
else {
int l = checkEqualSumUtil(
arr, N, sm1 + arr[j],
sm2, sm3, j + 1);
int m = checkEqualSumUtil(
arr, N, sm1, sm2 + arr[j],
sm3, j + 1);
int r = checkEqualSumUtil(
arr, N, sm1, sm2,
sm3 + arr[j], j + 1);
return dp[s] = max(max(l, m), r);
}
}
void checkEqualSum( int arr[], int N)
{
int sum1, sum2, sum3;
sum1 = sum2 = sum3 = 0;
if (checkEqualSumUtil(
arr, N, sum1,
sum2, sum3, 0)
== 1) {
cout << "Yes" ;
}
else {
cout << "No" ;
}
}
int main()
{
int arr[]
= { 17, 34, 59, 23, 17, 67,
57, 2, 18, 59, 1 };
int N = sizeof (arr) / sizeof (arr[0]);
checkEqualSum(arr, N);
return 0;
}
|
Java
import java.util.*;
class GFG{
static HashMap<String,
Integer> dp = new HashMap<String,
Integer>();
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);
if (j == N)
{
if (sm1 == sm2 && sm2 == sm3)
return 1 ;
else
return 0 ;
}
if (dp.containsKey(s))
return dp.get(s);
else
{
int l = checkEqualSumUtil(arr, N, sm1 + arr[j],
sm2, sm3, j + 1 );
int m = checkEqualSumUtil(arr, N, sm1,
sm2 + arr[j],
sm3, j + 1 );
int r = checkEqualSumUtil(arr, N, sm1, sm2,
sm3 + arr[j], j + 1 );
dp.put(s, Math.max(Math.max(l, m), r));
return dp.get(s);
}
}
static void checkEqualSum( int arr[], int N)
{
int sum1, sum2, sum3;
sum1 = sum2 = sum3 = 0 ;
if (checkEqualSumUtil(arr, N, sum1,
sum2, sum3, 0 ) == 1 )
{
System.out.print( "Yes" );
}
else
{
System.out.print( "No" );
}
}
public static void main(String[] args)
{
int arr[] = { 17 , 34 , 59 , 23 , 17 ,
67 , 57 , 2 , 18 , 59 , 1 };
int N = arr.length;
checkEqualSum(arr, N);
}
}
|
Python3
dp = {}
def checkEqualSumUtil(arr, N, sm1, sm2, sm3, j):
s = str (sm1) + "_" + str (sm2) + str (j)
if j = = N:
if sm1 = = sm2 and sm2 = = sm3:
return 1
else :
return 0
if s in dp:
return dp[s]
l = checkEqualSumUtil(arr, N, sm1 + arr[j],
sm2, sm3, j + 1 )
m = checkEqualSumUtil(arr, N, sm1,
sm2 + arr[j], sm3,
j + 1 )
r = checkEqualSumUtil(arr, N, sm1,
sm2, sm3 + arr[j],
j + 1 )
dp[s] = max (l, m, r)
return dp[s]
def checkEqualSum(arr, N):
sum1 = sum2 = sum3 = 0
if checkEqualSumUtil(arr, N, sum1,
sum2, sum3, 0 ) = = 1 :
print ( "Yes" )
else :
print ( "No" )
arr = [ 17 , 34 , 59 , 23 , 17 ,
67 , 57 , 2 , 18 , 59 , 1 ]
N = len (arr)
checkEqualSum(arr, N)
|
C#
using System;
using System.Collections.Generic;
class GFG{
static Dictionary< string ,
int > dp = new Dictionary< string ,
int >();
static int checkEqualSumUtil( int []arr, int N,
int sm1, int sm2,
int sm3, int j)
{
string s = sm1.ToString() + "_" +
sm2.ToString() + j.ToString();
if (j == N)
{
if (sm1 == sm2 && sm2 == sm3)
return 1;
else
return 0;
}
if (dp.ContainsKey(s))
return dp[s];
else
{
int l = checkEqualSumUtil(arr, N, sm1 + arr[j],
sm2, sm3, j + 1);
int m = checkEqualSumUtil(arr, N, sm1,
sm2 + arr[j],
sm3, j + 1);
int r = checkEqualSumUtil(arr, N, sm1, sm2,
sm3 + arr[j], j + 1);
dp[s] = Math.Max(Math.Max(l, m), r);
return dp[s];
}
}
static void checkEqualSum( int []arr, int N)
{
int sum1, sum2, sum3;
sum1 = sum2 = sum3 = 0;
if (checkEqualSumUtil(arr, N, sum1,
sum2, sum3, 0) == 1)
{
Console.Write( "Yes" );
}
else
{
Console.Write( "No" );
}
}
public static void Main( string [] args)
{
int []arr = { 17, 34, 59, 23, 17,
67, 57, 2, 18, 59, 1 };
int N = arr.Length;
checkEqualSum(arr, N);
}
}
|
Javascript
<script>
var dp = new Map();
function checkEqualSumUtil(arr, N, sm1, sm2, sm3, j)
{
var s = (sm1.toString())
+ "_" + (sm2.toString())
+ (j.toString());
if (j == N) {
if (sm1 == sm2 && sm2 == sm3)
return 1;
else
return 0;
}
if (dp.has(s))
return dp[s];
else {
var l = checkEqualSumUtil(
arr, N, sm1 + arr[j],
sm2, sm3, j + 1);
var m = checkEqualSumUtil(
arr, N, sm1, sm2 + arr[j],
sm3, j + 1);
var r = checkEqualSumUtil(
arr, N, sm1, sm2,
sm3 + arr[j], j + 1);
return dp[s] = Math.max(Math.max(l, m), r);
}
}
function checkEqualSum(arr, N)
{
var sum1, sum2, sum3;
sum1 = sum2 = sum3 = 0;
if (checkEqualSumUtil(
arr, N, sum1,
sum2, sum3, 0)
== 1) {
document.write( "Yes" );
}
else {
document.write( "No" );
}
}
var arr
= [17, 34, 59, 23, 17, 67,
57, 2, 18, 59, 1];
var N = arr.length;
checkEqualSum(arr, N);
</script>
|
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.
Share your thoughts in the comments
Please Login to comment...