数组的两个子集的最大可能差异

给定一个 n 整数数组。数组可能包含重复元素，但任何元素的最高频率不得超过两个。您必须制作两个子集，使其元素之和的差异最大，并且它们共同包含给定数组的所有元素以及最重要的条件，任何子集都不应包含重复元素。
例子：

Input : arr[] = {5, 8, -1, 4}
Output : Maximum Difference = 18
Explanation : 
Let Subset A = {5, 8, 4} & Subset B = {-1}
Sum of elements of subset A = 17, of subset B = -1
Difference of Sum of Both subsets = 17 - (-1) = 18

Input : arr[] = {5, 8, 5, 4}
Output : Maximum Difference = 12
Explanation : 
Let Subset A = {5, 8, 4} & Subset B = {5}
Sum of elements of subset A = 17, of subset B = 5
Difference of Sum of Both subsets = 17 - 5 = 12

在解决这个问题之前，我们必须处理一些给定的条件，它们被列为：

• 在构建子集时，请注意任何子集都不应包含重复元素。为此，我们可以得出结论，所有频率为 2 的元素都将成为两个子集的一部分，因此总体而言它们对子集和的差异没有任何影响。所以，我们可以很容易地忽略它们。
• 为了使两个子集的元素总和的差异最大，我们必须以所有正元素属于一个子集而负元素属于其他子集的方式来制作子集。

时间复杂度为 O(n ² ) 的算法：

for i=0 to n-1
    isSingleOccurance = true;
    for  j= i+1 to n-1

        // if frequency of any element is two
        // make both equal to zero
        if arr[i] equals arr[j]
            arr[i] = arr[j] = 0
            isSingleOccurance = false;
            break;
            
    if isSingleOccurance == true
        if (arr[i] > 0)
            SubsetSum_1 += arr[i];
        else 
            SubsetSum_2 += arr[i];
return abs(SubsetSum_1 - SubsetSum2)

C++

// CPP find maximum difference of subset sum
#include 
using namespace std;
 
// function for maximum subset diff
int maxDiff(int arr[], int n)
{
    int SubsetSum_1 = 0, SubsetSum_2 = 0;
    for (int i = 0; i <= n - 1; i++) {
 
        bool isSingleOccurance = true;
        for (int j = i + 1; j <= n - 1; j++) {
 
            // if frequency of any element is two
            // make both equal to zero
            if (arr[i] == arr[j]) {
                isSingleOccurance = false;
                arr[i] = arr[j] = 0;
                break;
            }
        }
        if (isSingleOccurance) {
            if (arr[i] > 0)
                SubsetSum_1 += arr[i];
            else
                SubsetSum_2 += arr[i];
        }
    }
    return abs(SubsetSum_1 - SubsetSum_2);
}
 
// driver program
int main()
{
    int arr[] = { 4, 2, -3, 3, -2, -2, 8 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Maximum Difference = " << maxDiff(arr, n);
    return 0;
}

Java

// java find maximum difference
// of subset sum
import java .io.*;
 
public class GFG {
     
    // function for maximum subset diff
    static int maxDiff(int []arr, int n)
    {
        int SubsetSum_1 = 0, SubsetSum_2 = 0;
        for (int i = 0; i <= n - 1; i++)
        {
            boolean isSingleOccurance = true;
            for (int j = i + 1; j <= n - 1; j++)
            {
     
                // if frequency of any element
                // is two make both equal to
                // zero
                if (arr[i] == arr[j])
                {
                    isSingleOccurance = false;
                    arr[i] = arr[j] = 0;
                    break;
                }
            }
            if (isSingleOccurance)
            {
                if (arr[i] > 0)
                    SubsetSum_1 += arr[i];
                else
                    SubsetSum_2 += arr[i];
            }
        }
         
        return Math.abs(SubsetSum_1 - SubsetSum_2);
    }
     
    // driver program
    static public void main (String[] args)
    {
        int []arr = { 4, 2, -3, 3, -2, -2, 8 };
        int n = arr.length;
         
        System.out.println("Maximum Difference = "
                               + maxDiff(arr, n));
    }
}
 
// This code is contributed by vt_m.

Python3

# Python3 find maximum difference
# of subset sum
 
import math
 
# function for maximum subset diff
def maxDiff(arr, n) :
    SubsetSum_1 = 0
    SubsetSum_2 = 0
    for i in range(0, n) :
 
        isSingleOccurance = True
        for j in range(i + 1, n) :
 
            # if frequency of any element
            # is two make both equal to
            # zero
            if (arr[i] == arr[j]) :
                isSingleOccurance = False
                arr[i] = arr[j] = 0
                break
 
        if (isSingleOccurance == True) :
            if (arr[i] > 0) :
                SubsetSum_1 += arr[i]
            else :
                SubsetSum_2 += arr[i]
 
    return abs(SubsetSum_1 - SubsetSum_2)
 
# Driver Code
arr = [4, 2, -3, 3, -2, -2, 8]
n = len(arr)
print ("Maximum Difference = {}"
               . format(maxDiff(arr, n)))
 
# This code is contributed by Manish Shaw
# (manishshaw1)

C#

// C# find maximum difference of
// subset sum
using System;
 
public class GFG {
     
    // function for maximum subset diff
    static int maxDiff(int []arr, int n)
    {
        int SubsetSum_1 = 0, SubsetSum_2 = 0;
        for (int i = 0; i <= n - 1; i++)
        {
     
            bool isSingleOccurance = true;
            for (int j = i + 1; j <= n - 1; j++)
            {
     
                // if frequency of any element
                // is two make both equal to
                // zero
                if (arr[i] == arr[j])
                {
                    isSingleOccurance = false;
                    arr[i] = arr[j] = 0;
                    break;
                }
            }
            if (isSingleOccurance)
            {
                if (arr[i] > 0)
                    SubsetSum_1 += arr[i];
                else
                    SubsetSum_2 += arr[i];
            }
        }
         
        return Math.Abs(SubsetSum_1 - SubsetSum_2);
    }
     
    // driver program
    static public void Main ()
    {
        int []arr = { 4, 2, -3, 3, -2, -2, 8 };
        int n = arr.Length;
         
        Console.WriteLine("Maximum Difference = "
                              + maxDiff(arr, n));
    }
}
 
// This code is contributed by vt_m.

PHP

 0)
                $SubsetSum_1 += $arr[$i];
            else
                $SubsetSum_2 += $arr[$i];
        }
    }
    return abs($SubsetSum_1 - $SubsetSum_2);
}
 
    // Driver Code
    $arr = array(4, 2, -3, 3, -2, -2, 8);
    $n = sizeof($arr);
    echo "Maximum Difference = " , maxDiff($arr, $n);
 
// This code is contributed by nitin mittal
?>

Javascript

 
// JavaScript Program to find maximum difference
// of subset sum
 
    // function for maximum subset diff
    function maxDiff(arr, n)
    {
        let SubsetSum_1 = 0, SubsetSum_2 = 0;
        for (let i = 0; i <= n - 1; i++)
        {
            let isSingleOccurance = true;
            for (let j = i + 1; j <= n - 1; j++)
            {
      
                // if frequency of any element
                // is two make both equal to
                // zero
                if (arr[i] == arr[j])
                {
                    isSingleOccurance = false;
                    arr[i] = arr[j] = 0;
                    break;
                }
            }
            if (isSingleOccurance)
            {
                if (arr[i] > 0)
                    SubsetSum_1 += arr[i];
                else
                    SubsetSum_2 += arr[i];
            }
        }
          
        return Math.abs(SubsetSum_1 - SubsetSum_2);
    }
      
 
// Driver program
 
        let arr = [ 4, 2, -3, 3, -2, -2, 8 ];
        let n = arr.length;
          
        document.write("Maximum Difference = "
                               + maxDiff(arr, n));
         
        // This code is contributed by susmitakundugoaldanga.

输出：

Maximum Difference = 20

时间复杂度为 O(n log n) 的算法：

-> sort the array
-> for i =0 to n-2
      // consecutive two elements are not equal
      // add absolute arr[i] to result
      if arr[i] != arr[i+1]
          result += abs(arr[i])
      // else skip next element too
      else
          i++;
          
// special check for last two elements
-> if (arr[n-2] != arr[n-1])
    result += arr[n-1]

-> return result;

C++

// CPP find maximum difference of subset sum
#include 
using namespace std;
 
// function for maximum subset diff
int maxDiff(int arr[], int n)
{
    int result = 0;
 
    // sort the array
    sort(arr, arr + n);
 
    // calculate the result
    for (int i = 0; i < n - 1; i++) {
        if (arr[i] != arr[i + 1])
            result += abs(arr[i]);
        else
            i++;
    }
 
    // check for last element
    if (arr[n - 2] != arr[n - 1])
        result += abs(arr[n - 1]);
 
    // return result
    return result;
}
 
// driver program
int main()
{
    int arr[] = { 4, 2, -3, 3, -2, -2, 8 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Maximum Difference = " << maxDiff(arr, n);
    return 0;
}

Java

// java find maximum difference of
// subset sum
import java. io.*;
import java .util.*;
 
public class GFG {
 
    // function for maximum subset diff
    static int maxDiff(int []arr, int n)
    {
        int result = 0;
     
        // sort the array
        Arrays.sort(arr);
     
        // calculate the result
        for (int i = 0; i < n - 1; i++)
        {
            if (arr[i] != arr[i + 1])
                result += Math.abs(arr[i]);
            else
                i++;
        }
     
        // check for last element
        if (arr[n - 2] != arr[n - 1])
            result += Math.abs(arr[n - 1]);
     
        // return result
        return result;
    }
     
    // driver program
    static public void main (String[] args)
    {
        int[] arr = { 4, 2, -3, 3, -2, -2, 8 };
        int n = arr.length;
         
        System.out.println("Maximum Difference = "
                                + maxDiff(arr, n));
    }
}
 
// This code is contributed by vt_m.

Python3

# Python 3 find maximum difference
# of subset sum
 
# function for maximum subset diff
def maxDiff(arr, n):
 
    result = 0
 
    # sort the array
    arr.sort()
 
    # calculate the result
    for i in range(n - 1):
        if (abs(arr[i]) != abs(arr[i + 1])):
            result += abs(arr[i])
 
        else:
            pass
 
    # check for last element
    if (arr[n - 2] != arr[n - 1]):
        result += abs(arr[n - 1])
 
    # return result
    return result
 
# Driver Code
if __name__ == "__main__":
     
    arr = [ 4, 2, -3, 3, -2, -2, 8 ]
    n = len(arr)
    print("Maximum Difference = " ,
                   maxDiff(arr, n))
 
# This code is contributed by ita_c

C＃

// C# find maximum difference
// of subset sum
using System;
 
public class GFG {
 
    // function for maximum subset diff
    static int maxDiff(int []arr, int n)
    {
        int result = 0;
     
        // sort the array
        Array.Sort(arr);
     
        // calculate the result
        for (int i = 0; i < n - 1; i++)
        {
            if (arr[i] != arr[i + 1])
                result += Math.Abs(arr[i]);
            else
                i++;
        }
     
        // check for last element
        if (arr[n - 2] != arr[n - 1])
            result += Math.Abs(arr[n - 1]);
     
        // return result
        return result;
    }
     
    // driver program
    static public void Main ()
    {
        int[] arr = { 4, 2, -3, 3, -2, -2, 8 };
        int n = arr.Length;
         
        Console.WriteLine("Maximum Difference = "
                              + maxDiff(arr, n));
    }
}
 
// This code is contributed by vt_m.

Javascript

 
// Javascript find maximum difference of subset sum
 
// function for maximum subset diff
function maxDiff(arr, n)
{
    var result = 0;
 
    // sort the array
    arr.sort((a,b)=> a-b)
 
    // calculate the result
    for (var i = 0; i < n - 1; i++) {
        if (arr[i] != arr[i + 1])
            result += Math.abs(arr[i]);
        else
            i++;
    }
 
    // check for last element
    if (arr[n - 2] != arr[n - 1])
        result += Math.abs(arr[n - 1]);
 
    // return result
    return result;
}
 
// driver program
var arr = [ 4, 2, -3, 3, -2, -2, 8 ];
var n = arr.length;
document.write( "Maximum Difference = " + maxDiff(arr, n));
 

输出：

Maximum Difference = 20

时间复杂度为 O(n) 的算法：

make hash table for positive elements:
    for all positive elements(arr[i])
        if frequency == 1
            SubsetSum_1 += arr[i];
make hash table for negative elements:
    for all negative elements
        if frequency == 1
            SubsetSum_2 += arr[i];
return abs(SubsetSum_1 - SubsetSum2)

C++

// CPP find maximum difference of subset sum
#include 
using namespace std;
 
// function for maximum subset diff
int maxDiff(int arr[], int n)
{
    unordered_map hashPositive;
    unordered_map hashNegative;
 
    int SubsetSum_1 = 0, SubsetSum_2 = 0;
 
    // construct hash for positive elements
    for (int i = 0; i <= n - 1; i++)
        if (arr[i] > 0)
            hashPositive[arr[i]]++;
 
    // calculate subset sum for positive elements
    for (int i = 0; i <= n - 1; i++)
        if (arr[i] > 0 && hashPositive[arr[i]] == 1)
            SubsetSum_1 += arr[i];
 
    // construct hash for negative elements
    for (int i = 0; i <= n - 1; i++)
        if (arr[i] < 0)
            hashNegative[abs(arr[i])]++;
 
    // calculate subset sum for negative elements
    for (int i = 0; i <= n - 1; i++)
        if (arr[i] < 0 &&
            hashNegative[abs(arr[i])] == 1)
            SubsetSum_2 += arr[i];
 
    return abs(SubsetSum_1 - SubsetSum_2);
}
 
// driver program
int main()
{
    int arr[] = { 4, 2, -3, 3, -2, -2, 8 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Maximum Difference = " << maxDiff(arr, n);
    return 0;
}

Java

// Java find maximum
// difference of subset sum
import java.util.*;
class GFG{
   
// Function for maximum subset diff
public static int maxDiff(int arr[],
                          int n)
{
  HashMap hashPositive = new HashMap<>();
  HashMap hashNegative = new HashMap<>();
 
  int SubsetSum_1 = 0,
      SubsetSum_2 = 0;
 
  // Construct hash for
  // positive elements
  for (int i = 0; i <= n - 1; i++)
  {
    if (arr[i] > 0)
    {
      if(hashPositive.containsKey(arr[i]))
      {
        hashPositive.replace(arr[i],
        hashPositive.get(arr[i]) + 1);
      }
      else
      {
        hashPositive.put(arr[i], 1);
      }
    }
  }
 
  // Calculate subset sum
  // for positive elements
  for (int i = 0; i <= n - 1; i++)
  {
    if(arr[i] > 0 &&
       hashPositive.containsKey(arr[i]))
    {
      if(hashPositive.get(arr[i]) == 1)
      {
        SubsetSum_1 += arr[i];
      }
    }
  }
 
  // Construct hash for
  // negative elements
  for (int i = 0; i <= n - 1; i++)
  {
    if (arr[i] < 0)
    {
      if(hashNegative.containsKey(Math.abs(arr[i])))
      {
        hashNegative.replace(Math.abs(arr[i]),
        hashNegative.get(Math.abs(arr[i])) + 1);
      }
      else
      {
        hashNegative.put(Math.abs(arr[i]), 1);
      }
    }
  }
 
  // Calculate subset sum for
  // negative elements
  for (int i = 0; i <= n - 1; i++)
  {
    if (arr[i] < 0 &&
        hashNegative.containsKey(Math.abs(arr[i])))
    {
      if(hashNegative.get(Math.abs(arr[i])) == 1)
      {
        SubsetSum_2 += arr[i];
      }
    }
  }
 
  return Math.abs(SubsetSum_1 - SubsetSum_2);
}
 
// Driver code
public static void main(String[] args)
{
  int arr[] = {4, 2, -3, 3,
               -2, -2, 8};
  int n = arr.length;
  System.out.print("Maximum Difference = " +
                    maxDiff(arr, n));
}
}
 
// This code is contributed by divyeshrabadiya07

蟒蛇3

# Python3 find maximum difference of subset sum
 
# function for maximum subset diff
def maxDiff(arr, n):
 
    hashPositive = dict()
    hashNegative = dict()
 
    SubsetSum_1, SubsetSum_2 = 0, 0
 
    # construct hash for positive elements
    for i in range(n):
        if (arr[i] > 0):
            hashPositive[arr[i]] = \
                hashPositive.get(arr[i], 0) + 1
 
    # calculate subset sum for positive elements
    for i in range(n):
        if (arr[i] > 0 and arr[i] in
            hashPositive.keys() and
            hashPositive[arr[i]] == 1):
            SubsetSum_1 += arr[i]
 
    # construct hash for negative elements
    for i in range(n):
        if (arr[i] < 0):
            hashNegative[abs(arr[i])] = \
                hashNegative.get(abs(arr[i]), 0) + 1
 
    # calculate subset sum for negative elements
    for i in range(n):
        if (arr[i] < 0 and abs(arr[i]) in
            hashNegative.keys() and
            hashNegative[abs(arr[i])] == 1):
            SubsetSum_2 += arr[i]
 
    return abs(SubsetSum_1 - SubsetSum_2)
 
# Driver Code
arr = [4, 2, -3, 3, -2, -2, 8]
n = len(arr)
print("Maximum Difference =", maxDiff(arr, n))
 
# This code is contributed by mohit kumar

C＃

// C# find maximum
// difference of subset sum
using System;
using System.Collections.Generic;
 
class GFG {
 
    // Function for maximum subset diff
    static int maxDiff(int[] arr, int n)
    {
      Dictionary hashPositive =
        new Dictionary();
      Dictionary hashNegative =
        new Dictionary();
      
      int SubsetSum_1 = 0, SubsetSum_2 = 0;
      
      // Construct hash for
      // positive elements
      for (int i = 0; i <= n - 1; i++)
      {
        if (arr[i] > 0)
        {
          if(hashPositive.ContainsKey(arr[i]))
          {
            hashPositive[arr[i]] += 1;
          }
          else
          {
            hashPositive.Add(arr[i], 1);
          }
        }
      }
      
      // Calculate subset sum
      // for positive elements
      for (int i = 0; i <= n - 1; i++)
      {
        if(arr[i] > 0 && hashPositive.ContainsKey(arr[i]))
        {
          if(hashPositive[arr[i]] == 1)
          {
            SubsetSum_1 += arr[i];
          }
        }
      }
      
      // Construct hash for
      // negative elements
      for (int i = 0; i <= n - 1; i++)
      {
        if (arr[i] < 0)
        {
          if(hashNegative.ContainsKey(Math.Abs(arr[i])))
          {
            hashNegative[Math.Abs(arr[i])] += 1;
          }
          else
          {
            hashNegative.Add(Math.Abs(arr[i]), 1);
          }
        }
      }
      
      // Calculate subset sum for
      // negative elements
      for (int i = 0; i <= n - 1; i++)
      {
        if (arr[i] < 0 &&
            hashNegative.ContainsKey(Math.Abs(arr[i])))
        {
          if(hashNegative[Math.Abs(arr[i])] == 1)
          {
            SubsetSum_2 += arr[i];
          }
        }
      }
      
      return Math.Abs(SubsetSum_1 - SubsetSum_2);
    }
   
  // Driver code 
  static void Main() {
      int[] arr = {4, 2, -3, 3, -2, -2, 8};
      int n = arr.Length;
      Console.WriteLine("Maximum Difference = " +
                        maxDiff(arr, n));
  }
}
 
// This code is contributed by divesh072019

Javascript

// Javascript find maximum
// difference of subset sum
 
// Function for maximum subset diff
function maxDiff(arr,n)
{
    let hashPositive = new Map();
  let hashNegative = new Map();
  
  let SubsetSum_1 = 0,
      SubsetSum_2 = 0;
  
  // Construct hash for
  // positive elements
  for (let i = 0; i <= n - 1; i++)
  {
    if (arr[i] > 0)
    {
      if(hashPositive.has(arr[i]))
      {
        hashPositive.set(arr[i],
        hashPositive.get(arr[i]) + 1);
      }
      else
      {
        hashPositive.set(arr[i], 1);
      }
    }
  }
  
  // Calculate subset sum
  // for positive elements
  for (let i = 0; i <= n - 1; i++)
  {
    if(arr[i] > 0 &&
       hashPositive.has(arr[i]))
    {
      if(hashPositive.get(arr[i]) == 1)
      {
        SubsetSum_1 += arr[i];
      }
    }
  }
  
  // Construct hash for
  // negative elements
  for (let i = 0; i <= n - 1; i++)
  {
    if (arr[i] < 0)
    {
      if(hashNegative.has(Math.abs(arr[i])))
      {
        hashNegative.set(Math.abs(arr[i]),
        hashNegative.get(Math.abs(arr[i])) + 1);
      }
      else
      {
        hashNegative.set(Math.abs(arr[i]), 1);
      }
    }
  }
  
  // Calculate subset sum for
  // negative elements
  for (let i = 0; i <= n - 1; i++)
  {
    if (arr[i] < 0 &&
        hashNegative.has(Math.abs(arr[i])))
    {
      if(hashNegative.get(Math.abs(arr[i])) == 1)
      {
        SubsetSum_2 += arr[i];
      }
    }
  }
  
  return Math.abs(SubsetSum_1 - SubsetSum_2);
         
}
 
// Driver code
 
let arr = [4, 2, -3, 3,
               -2, -2, 8];
let n = arr.length;
document.write("Maximum Difference = " +
                    maxDiff(arr, n));
                 
    // This code is contributed by rag2127

输出：

Maximum Difference = 20

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。