# Equal sum array partition excluding a given element

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 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
```

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

Approach: This problem is a variation of partition problem with an additional constraint that index cannot be included in neither 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.

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 ` `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); ` ` `  `    ``if` `(canPartition(arr, n, index))  ` `        ``cout << ``"Yes"``;     ` `    ``else`  `        ``cout << ``"No"``;     ` `    ``return` `0; ` `} `

## Java

 `// 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

 `# 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#

 `// 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

 ` `

Output :

```Yes
```

Time Complexity : Exponential O(2^n)
Exercise : Try to solve this problem iteratively.

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.

Improved By : manishshaw1

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.