Minimize Subset sum difference after deleting K elements of Array
Last Updated :
26 Apr, 2022
Given an array arr[] containing N integers and an integer K, the task is to minimize the subset-sum difference after removing K elements from the given array.
Note: The subsets must be non-empty.
Examples:
Input: arr[] = {7, 9, 5, 8, 1, 3}, K = 2
Output: -23
Explanation: Remove 5 and 3 from the array and form subsets [1] and [7, 8, 9].
The subset difference of these subset is 1 - 24 = -23 that is the minimum possible difference.
Input: arr[] = {7, 9, 5, 8}, K = 3
Output: -1
Explanation: If 3 elements are removed it is not possible to form two non-empty subsets.
Approach: The problem can be solved using recursion based on the following idea:
For each element of the array there are 3 choices: either it can be deleted or be a part of any of the two subsets. Form all the possible subsets after deleting K elements and find the one where the difference of subset sums is the minimum.
Instead of considering the three options for each array element, only two options can be considered: either deleted or part of first subset (because if the sum of first subset elements are known then the other subset sum = array sum - first subset sum)
Follow the steps mentioned to solve the problem:
- Calculate the sum of all the array elements.
- Iterate recursively for each array element:
- Delete this if K elements are not already deleted and continue for the next index.
- Consider this as part of one subset.
- If the whole array is traversed, check the difference between two subset sums.
- The minimum difference is the required answer.
Below is the implementation for the above-mentioned approach:
C++
// C++ code to implement the above approach
#include <bits/stdc++.h>
using namespace std;
int mini = INT_MAX;
// Function to form all possible subsets
void subset(vector<int> arr, int index, int sum, int total)
{
if (index >= arr.size()) {
if (sum != 0)
mini = min(mini, sum - (total - sum));
return;
}
subset(arr, index + 1, sum + arr[index], total);
subset(arr, index + 1, sum, total);
}
// Function to get the minimum difference
static void print(int index, vector<int>& arr, int total,
vector<int>& ans)
{
if (total == 0) {
int sum = 0;
for (int elements : ans) {
sum += elements;
}
// Function call to form subset
subset(ans, 0, 0, sum);
return;
}
if (index >= arr.size()) {
return;
}
ans.push_back(arr[index]);
print(index + 1, arr, total - 1, ans);
ans.pop_back();
print(index + 1, arr, total, ans);
}
// Utility function to solve the problem
void solve(vector<int>& arr, int N)
{
int selected = arr.size() - N;
if (selected <= 1) {
cout << -1;
return;
}
vector<int> ans;
print(0, arr, selected, ans);
}
// Driver code
int main()
{
vector<int> arr = { 7, 9, 5, 8, 1, 3 };
int N = 2;
solve(arr, N);
cout << (mini);
return 0;
}
// This code is contributed by rakeshsahni
// Java code to implement the above approach
import java.io.*;
import java.util.*;
class GFG {
static int min = Integer.MAX_VALUE;
// Function to form all possible subsets
static void subset(List<Integer> arr,
int index,
int sum, int total)
{
if (index >= arr.size()) {
if (sum != 0)
min = Math.min(min,
sum - (total - sum));
return;
}
subset(arr, index + 1,
sum + arr.get(index), total);
subset(arr, index + 1, sum, total);
}
// Function to get the minimum difference
static void print(int index, int arr[],
int total,
List<Integer> ans)
{
if (total == 0) {
int sum = 0;
for (int elements : ans) {
sum += elements;
}
// Function call to form subset
subset(ans, 0, 0, sum);
return;
}
if (index >= arr.length) {
return;
}
ans.add(arr[index]);
print(index + 1, arr, total - 1, ans);
ans.remove(ans.size() - 1);
print(index + 1, arr, total, ans);
}
// Utility function to solve the problem
public static void solve(int arr[], int N)
{
int selected = arr.length - N;
if (selected <= 1) {
System.out.println(-1);
return;
}
List<Integer> ans = new ArrayList<>();
print(0, arr, selected, ans);
}
// Driver code
public static void main(String[] args)
{
int arr[] = { 7, 9, 5, 8, 1, 3 };
int N = 2;
solve(arr, N);
System.out.println(min);
}
}
# Python code to implement the above approach
import sys
# Function to form all possible subsets
def subset(arr,index,sum,total):
global mini
if (index >= len(arr)):
if (sum != 0):
mini = min(mini, sum - (total - sum))
return
subset(arr, index + 1, sum + arr[index], total)
subset(arr, index + 1, sum, total)
# Function to get the minimum difference
def Print(index,arr,total,ans):
if (total == 0):
sum = 0
for elements in ans:
sum += elements
# Function call to form subset
subset(ans, 0, 0, sum)
return
if (index >= len(arr)):
return
ans.append(arr[index])
Print(index + 1, arr, total - 1, ans)
ans.pop()
Print(index + 1, arr, total, ans)
# Utility function to solve the problem
def solve(arr,N):
selected = len(arr) - N
if (selected <= 1):
print(-1)
return
ans = []
Print(0, arr, selected, ans)
# Driver code
if __name__=="__main__":
mini = sys.maxsize
arr = [ 7, 9, 5, 8, 1, 3 ]
N = 2
solve(arr, N)
print(mini)
# This code is contributed by shinjanpatra
// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
class GFG
{
static int min = Int32.MaxValue;
// Function to form all possible subsets
static void subset(List<int> arr,
int index,
int sum, int total)
{
if (index >= arr.Count) {
if (sum != 0)
min = Math.Min(min,
sum - (total - sum));
return;
}
subset(arr, index + 1,
sum + arr[index], total);
subset(arr, index + 1, sum, total);
}
// Function to get the minimum difference
static void print(int index, int[] arr,
int total,
List<int> ans)
{
if (total == 0) {
int sum = 0;
foreach (int elements in ans) {
sum += elements;
}
// Function call to form subset
subset(ans, 0, 0, sum);
return;
}
if (index >= arr.Length) {
return;
}
ans.Add(arr[index]);
print(index + 1, arr, total - 1, ans);
ans.RemoveAt(ans.Count - 1);
print(index + 1, arr, total, ans);
}
// Utility function to solve the problem
public static void solve(int[] arr, int N)
{
int selected = arr.Length - N;
if (selected <= 1) {
Console.Write(-1);
return;
}
List<int> ans = new List<int>();
print(0, arr, selected, ans);
}
// Driver Code
public static void Main()
{
int[] arr = { 7, 9, 5, 8, 1, 3 };
int N = 2;
solve(arr, N);
Console.Write(min);
}
}
// This code is contributed by sanjoy_62.
<script>
// JavaScript code to implement the above approach
let mini = Number.MAX_VALUE;
// Function to form all possible subsets
function subset(arr,index,sum,total)
{
if (index >= arr.length) {
if (sum != 0)
mini = Math.min(mini, sum - (total - sum));
return;
}
subset(arr, index + 1, sum + arr[index], total);
subset(arr, index + 1, sum, total);
}
// Function to get the minimum difference
function print(index,arr,total,ans)
{
if (total == 0) {
sum = 0;
for (let elements of ans) {
sum += elements;
}
// Function call to form subset
subset(ans, 0, 0, sum);
return;
}
if (index >= arr.length) {
return;
}
ans.push(arr[index]);
print(index + 1, arr, total - 1, ans);
ans.pop();
print(index + 1, arr, total, ans);
}
// Utility function to solve the problem
function solve(arr,N)
{
let selected = arr.length - N;
if (selected <= 1) {
document.write(-1);
return;
}
let ans = [];
print(0, arr, selected, ans);
}
// Driver code
let arr = [ 7, 9, 5, 8, 1, 3 ];
let N = 2;
solve(arr, N);
document.write(mini);
// This code is contributed by shinjanpatra
</script>
Time Complexity: O(2N)
Auxiliary Space: O(N)
Similar Reads
Array element with minimum sum of absolute differences | Set 2 Given an array arr[] consisting of N positive integers, the task is to find an array element X such that sum of its absolute differences with every array element is minimum. Examples: Input: arr[] = {1, 2, 3, 4, 5}Output: 3Explanation: For element arr[0](= 1): |(1 - 1)| + |(2 - 1)| + |(3 - 1)| + |(4
7 min read
Maximum possible middle element of the array after deleting exactly k elements Given an integer array of size n and a number k. If the indexing is 1 based then the middle element of the array is the element at index (n + 1) / 2, if n is odd otherwise n / 2. The task is to delete exactly k elements from the array in such a way that the middle element of the reduced array is as
8 min read
Minimize sum by dividing all elements of a subarray by K Given an array arr[] of N integers and a positive integer K, the task is to minimize the sum of the array elements after performing the given operation atmost one time. The operation is to choose a subarray and divide all elements of the subarray by K. Find and print the minimum possible sum.Example
6 min read
Split array into K subarrays with minimum sum of absolute difference between adjacent elements Given an array, arr[] of size N and an integer K, the task is to split the array into K subarrays minimizing the sum of absolute difference between adjacent elements of each subarray. Examples: Input: arr[] = {1, 3, -2, 5, -1}, K = 2Output: 13Explanation: Split the array into following 2 subarrays:
8 min read
Split array into K Subarrays to minimize sum of difference between min and max Given a sorted array arr[] of size N and integer K, the task is to split the array into K non-empty subarrays such that the sum of the difference between the maximum element and the minimum element of each subarray is minimized. Note: Every element of the array must be included in one subarray and e
6 min read