Equal sum array partition excluding a given element
Last Updated :
18 Feb, 2023
Given an array arr[] and an index in it. Find whether the array arr[] can be partitioned into two disjoint sets such that sum of both the sets is equal and none of the sets includes arr[index]
Examples :
Input : arr[] = {2, 1, 3, 4},
index = 2
Output : No
We need to exclude arr[2] which is 3.
Possible sets are :
Set 1: (2, 1), Set 2: 4, sum = 3?4
Set 1: 2, Set 2: (4, 1), sum = 2?5
Set 1: 1, Set 2: (4, 2), sum = 1?6
Neither of the sums are equal.
Input : arr[] = {2, 5, 1, 4, 0},
index = 4
Output : Yes
Set 1 : (2, 4), sum = 6
Set 2 : (5, 1), sum = 6
Approach: This problem is a variation of partition problem with an additional constraint that index cannot be included in either of the partitioned sets of array.
First find sum S of array excluding the index-th element. If the sum is even then array can be partitioned otherwise not. If the sum is even then define two variables set1Sum and set2Sum to store the sum of two sets.
It can be determined recursively that whether set1Sum is equal to set2Sum. Start from position 0 and traverse the array recursively. At every array position, there are two choices: either include current array element in set 1 or in set 2. Recursively call for both the conditions, by including current element in set 1 first then in set 2. If current position is the index to be excluded then recursively call for next position without updating any sum. When entire array is traversed then check for equality of both sets sum. If the sums are equal then result is found otherwise backtrack and check for other possibilities.
Steps to solve this problem:
1. Define a function isSubsetSumPoss that takes in an array arr, the number of elements in the array n, the sum of the first set set1Sum, the sum of the second set set2Sum, the index of the element that is to be excluded index, and the current position in the array pos.
2. If pos is equal to n, then the function returns whether set1Sum is equal to set2Sum.
3. If pos is equal to index, then the function calls itself with pos incremented by 1 without updating set1Sum or set2Sum.
4. If pos is not equal to index, then the function calls itself twice: once with set1Sum incremented by the value of arr[pos] and once with set2Sum incremented by the value of arr[pos].
5. Define a function canPartition that takes in an array arr, the number of elements in the array n, and the index of the element that is to be excluded index.
6. Calculate the sum of the entire array excluding the element at position index.
7. If the sum is not even, then return false as it is not possible to partition the array into two equal sum sets.
8. If the sum is even, call the isSubsetSumPoss function with set1Sum and set2Sum initialized to 0, index equal to the passed in index, and pos equal to 0. Return the result of the isSubsetSumPoss function.
Implementation:
C++
// C++ program to determine whether an array can be
// partitioned into two equal sum sets when an index
// is always excluded from both sets.
#include <bits/stdc++.h>
using namespace std;
// Utility function to partition array into two sets
// and check whether sum of both sets are equal or not.
bool isSubsetSumPoss(int arr[], int n, int set1Sum,
int set2Sum, int index, int pos)
{
// If the entire array is traversed, then check
// whether sum of both the sets are equal or not.
if (pos == n)
return (set1Sum == set2Sum);
// If current position is the index to be excluded
// then call the function for next position without
// updating any sum.
if (pos == index)
isSubsetSumPoss(arr, n, set1Sum,
set2Sum, index, pos + 1);
// Each element can be included either in
// set 1 or in set 2. Call function for
// both the cases.
return isSubsetSumPoss(arr, n, set1Sum + arr[pos],
set2Sum, index, pos + 1)
|| isSubsetSumPoss(arr, n, set1Sum, set2Sum +
arr[pos], index, pos + 1);
}
// Function that calls the main utility
// function and returns whether array can
// be partitioned into two sets or not.
bool canPartition(int arr[], int n, int index)
{
// Calculate sum of entire array
// excluding position index.
int sum = 0;
for (int i = 0; i < n; i++) {
if (i == index)
continue;
sum += arr[i];
}
// If sum is not even then array
// cannot be partitioned into two
// equal sum sets.
if (sum % 2 != 0)
return false;
// If sum is even call utility function.
return isSubsetSumPoss(arr, n, 0, 0,
index, 0);
}
int main()
{
int arr[] = { 2, 5, 1, 4, 0 };
int index = 4;
int n = sizeof(arr) / sizeof(arr[0]);
if (canPartition(arr, n, index))
cout << "Yes";
else
cout << "No";
return 0;
}
// Java program to determine whether an array
// can be partitioned into two equal sum
// sets when an index is always excluded
// from both sets.
import java.io.*;
import java.util.*;
public class GFG {
// Utility function to partition array
// into two sets and check whether sum
// of both sets are equal or not.
static boolean isSubsetSumPoss(int []arr,
int n, int set1Sum, int set2Sum,
int index, int pos)
{
// If the entire array is traversed,
// then check whether sum of both
// the sets are equal or not.
if (pos == n)
return (set1Sum == set2Sum);
// If current position is the index
// to be excluded then call the
// function for next position without
// updating any sum.
if (pos == index)
isSubsetSumPoss(arr, n, set1Sum,
set2Sum, index, pos + 1);
// Each element can be included
// either in set 1 or in set 2.
// Call function for both the cases.
return isSubsetSumPoss(arr, n, set1Sum
+ arr[pos], set2Sum, index, pos + 1)
|| isSubsetSumPoss(arr, n, set1Sum,
set2Sum + arr[pos], index, pos + 1);
}
// Function that calls the main utility
// function and returns whether array can
// be partitioned into two sets or not.
static boolean canPartition(int []arr, int n,
int index)
{
// Calculate sum of entire array
// excluding position index.
int sum = 0;
for (int i = 0; i < n; i++) {
if (i == index)
continue;
sum += arr[i];
}
// If sum is not even then array
// cannot be partitioned into two
// equal sum sets.
if (sum % 2 != 0)
return false;
// If sum is even call utility function.
return isSubsetSumPoss(arr, n, 0, 0,
index, 0);
}
// Driver code
public static void main(String args[])
{
int []arr = { 2, 5, 1, 4, 0 };
int index = 4;
int n = arr.length;
if (canPartition(arr, n, index))
System.out.print("Yes");
else
System.out.print("No");
}
}
// This code is contributed by Manish Shaw
// (manishshaw1)
# Python3 program to determine whether an array can be
# partitioned into two equal sum sets when an index
# is always excluded from both sets.
# Utility function to partition array into two sets
# and check whether sum of both sets are equal or not.
def isSubsetSumPoss(arr, n, set1Sum, set2Sum, index, pos) :
# If the entire array is traversed, then check
# whether sum of both the sets are equal or not.
if (pos == n) :
return (set1Sum == set2Sum)
# If current position is the index to be excluded
# then call the function for next position without
# updating any sum.
if (pos == index) :
isSubsetSumPoss(arr, n, set1Sum, set2Sum,
index, pos + 1)
# Each element can be included either in
# set 1 or in set 2. Call function for
# both the cases.
return (isSubsetSumPoss(arr, n, set1Sum + arr[pos],
set2Sum, index, pos + 1)
or isSubsetSumPoss(arr, n, set1Sum,
set2Sum + arr[pos], index, pos + 1))
# Function that calls the main utility
# function and returns whether array can
# be partitioned into two sets or not.
def canPartition(arr, n, index) :
# Calculate sum of entire array
# excluding position index.
sum = 0
for i in range (0, n) :
if (i == index) :
continue
sum += arr[i]
# If sum is not even then array
# cannot be partitioned into two
# equal sum sets.
if (sum % 2 != 0) :
return false
# If sum is even call utility function.
return isSubsetSumPoss(arr, n, 0, 0, index, 0)
# Driver Code
arr = [ 2, 5, 1, 4, 0 ]
index = 4
n = len(arr)
if (canPartition(arr, n, index)) :
print ("Yes")
else :
print ("No")
# This code is contributed by Manish Shaw
# (manishshaw1)
// C# program to determine whether an array
// can be partitioned into two equal sum
// sets when an index is always excluded
// from both sets.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Collections;
class GFG {
// Utility function to partition array
// into two sets and check whether sum
// of both sets are equal or not.
static bool isSubsetSumPoss(int []arr,
int n, int set1Sum, int set2Sum,
int index, int pos)
{
// If the entire array is traversed,
// then check whether sum of both
// the sets are equal or not.
if (pos == n)
return (set1Sum == set2Sum);
// If current position is the index
// to be excluded then call the
// function for next position without
// updating any sum.
if (pos == index)
isSubsetSumPoss(arr, n, set1Sum,
set2Sum, index, pos + 1);
// Each element can be included
// either in set 1 or in set 2.
// Call function for both the cases.
return isSubsetSumPoss(arr, n, set1Sum
+ arr[pos], set2Sum, index, pos + 1)
|| isSubsetSumPoss(arr, n, set1Sum,
set2Sum + arr[pos], index, pos + 1);
}
// Function that calls the main utility
// function and returns whether array can
// be partitioned into two sets or not.
static bool canPartition(int []arr, int n,
int index)
{
// Calculate sum of entire array
// excluding position index.
int sum = 0;
for (int i = 0; i < n; i++) {
if (i == index)
continue;
sum += arr[i];
}
// If sum is not even then array
// cannot be partitioned into two
// equal sum sets.
if (sum % 2 != 0)
return false;
// If sum is even call utility function.
return isSubsetSumPoss(arr, n, 0, 0,
index, 0);
}
// Driver code
public static void Main()
{
int []arr = { 2, 5, 1, 4, 0 };
int index = 4;
int n = arr.Length;
if (canPartition(arr, n, index))
Console.Write("Yes");
else
Console.Write("No");
}
}
// This code is contributed by Manish Shaw
// (manishshaw1)
<?php
// PHP program to determine whether
// an array can be partitioned into
// two equal sum sets when an index
// is always excluded from both sets.
// Utility function to partition array
// into two sets and check whether sum
// of both sets are equal or not.
function isSubsetSumPoss($arr, $n, $set1Sum,
$set2Sum, $index, $pos)
{
// If the entire array is traversed,
// then check whether sum of both
// the sets are equal or not.
if ($pos == $n)
return ($set1Sum == $set2Sum);
// If current position is the index
// to be excluded then call the
// function for next position without
// updating any sum.
if ($pos == $index)
isSubsetSumPoss($arr, $n, $set1Sum,
$set2Sum, $index,
$pos + 1);
// Each element can be included
// either in set 1 or in set 2.
// Call function for both the cases.
return isSubsetSumPoss($arr, $n, $set1Sum +
$arr[$pos], $set2Sum,
$index, $pos + 1) ||
isSubsetSumPoss($arr, $n, $set1Sum,
$set2Sum + $arr[$pos],
$index, $pos + 1);
}
// Function that calls the main utility
// function and returns whether array can
// be partitioned into two sets or not.
function canPartition($arr, $n, $index)
{
// Calculate sum of entire array
// excluding position index.
$sum = 0;
for ($i = 0; $i < $n; $i++)
{
if ($i == $index)
continue;
$sum += $arr[$i];
}
// If sum is not even then array
// cannot be partitioned into two
// equal sum sets.
if ($sum % 2 != 0)
return false;
// If sum is even call
// utility function.
return isSubsetSumPoss($arr, $n, 0,
0, $index, 0);
}
// Driver Code
$arr = array( 2, 5, 1, 4, 0 );
$index = 4;
$n = count($arr);
if (canPartition($arr, $n, $index))
echo ("Yes");
else
echo ("No");
// This code is contributed by
// Manish Shaw (manishshaw1)
?>
<script>
// JavaScript program to determine whether an array
// can be partitioned into two equal sum
// sets when an index is always excluded
// Utility function to partition array
// into two sets and check whether sum
// of both sets are equal or not.
function isSubsetSumPoss(arr,
n, set1Sum, set2Sum,
index, pos)
{
// If the entire array is traversed,
// then check whether sum of both
// the sets are equal or not.
if (pos == n)
return (set1Sum == set2Sum);
// If current position is the index
// to be excluded then call the
// function for next position without
// updating any sum.
if (pos == index)
isSubsetSumPoss(arr, n, set1Sum,
set2Sum, index, pos + 1);
// Each element can be included
// either in set 1 or in set 2.
// Call function for both the cases.
return isSubsetSumPoss(arr, n, set1Sum
+ arr[pos], set2Sum, index, pos + 1)
|| isSubsetSumPoss(arr, n, set1Sum,
set2Sum + arr[pos], index, pos + 1);
}
// Function that calls the main utility
// function and returns whether array can
// be partitioned into two sets or not.
function canPartition(arr, n, index)
{
// Calculate sum of entire array
// excluding position index.
let sum = 0;
for (let i = 0; i < n; i++) {
if (i == index)
continue;
sum += arr[i];
}
// If sum is not even then array
// cannot be partitioned into two
// equal sum sets.
if (sum % 2 != 0)
return false;
// If sum is even call utility function.
return isSubsetSumPoss(arr, n, 0, 0,
index, 0);
}
// Driver code
let arr = [ 2, 5, 1, 4, 0 ];
let index = 4;
let n = arr.length;
if (canPartition(arr, n, index))
document.write("Yes");
else
document.write("No");
</script>
Time Complexity : O(2^n) ,The time complexity of this algorithm is O(2^n) where n is the size of the array. This is because the recursive function is called twice for each element, leading to an exponential time complexity.
Space complexity: O(n),The space complexity of this algorithm is O(n) where n is the size of the array. This is because the recursive call stack is of size n.
Exercise : Try to solve this problem iteratively.
Similar Reads
Partition an array into two subsets with equal count of unique elements Given an array arr[] consisting of N integers, the task is to partition the array into two subsets such that the count of unique elements in both the subsets is the same and for each element, print 1 if that element belongs to the first subset. Otherwise, print 2. If it is not possible to do such a
13 min read
Partition Array into two Arrays of equal size to Minimize Sum Difference Given an integer array of size 2*n, partition the array into two arrays of equal length such that the absolute difference between the sums of these two arrays is minimum. Return this minimum difference. To partition the array, allocate each element to one of two arrays. Examples :Input: arr[] = {7,
15+ min read
Equalize an array using array elements only Given an array of integers, the task is to count minimum number of operations to equalize the array (make all array elements same). And return -1 if it is not possible to equalize. To equalize an array, we need to move values from higher numbers to smaller numbers. Number of operations is equal to n
6 min read
Minimum operations required to make two elements equal in Array Given array A[] of size N and integer X, the task is to find the minimum number of operations to make any two elements equal in the array. In one operation choose any element A[i] and replace it with A[i] & X. where & is bitwise AND. If such operations do not exist print -1. Examples: Input:
9 min read
Count pairs of equal elements possible by excluding each array element once Given an array arr[] of N integers, the task for each array element is to find the number of ways of choosing a pair of two equal elements excluding the current element. Examples: Input: arr[] = {1, 1, 2, 1, 2}Output: 2 2 3 2 3Explanation: For arr[0] (= 1): The remaining array elements are {1, 2, 1,
10 min read
Find a partition point in array Given an unsorted array of integers. Find an element such that all the elements to its left are smaller and to its right are greater. Print -1 if no such element exists. Note that there can be more than one such elements. For example an array which is sorted in increasing order all elements follow t
15 min read
Sorting all array elements except one Given an array, a positive integer, sort the array in ascending order such that the element at index K in the unsorted array stays unmoved and all other elements are sorted. Examples: Input : arr[] = {10, 4, 11, 7, 6, 20} k = 2; Output : arr[] = {4, 6, 11, 7, 10, 20} Input : arr[] = {30, 20, 10} k =
6 min read
Split array into three equal sum segments Given an integer array arr[], the task is to divide the array into three non-empty contiguous segments with equal sum. In other words, we need to return an index pair [i, j], such that sum(arr[0...i]) = sum(arr[i+1...j]) = sum(arr[j+1...n-1]). Note: If it is impossible to divide the array into three
14 min read
Find an element which divides the array in two subarrays with equal product Given, an array of size N. Find an element which divides the array into two sub-arrays with equal product. Print -1 if no such partition is not possible. Examples : Input : 1 4 2 1 4 Output : 2 If 2 is the partition, subarrays are : {1, 4} and {1, 4} Input : 2, 3, 4, 1, 4, 6 Output : 1 If 1 is the p
12 min read
Partition the array into three equal sum segments Given an array of n integers, we have to partition the array into three segments such that all the segments have an equal sum. Segment sum is the sum of all the elements in the segment. Examples: Input : 1, 3, 6, 2, 7, 1, 2, 8 Output : [1, 3, 6], [2, 7, 1], [2, 8] Input : 7, 6, 1, 7 Output : [7], [6
12 min read