从给定数组的所有子集中找到可能的最大差异之和。

给定一个包含 n 个非负整数（允许重复元素）的数组 arr[]，从给定数组的所有子集中找出可能的最大差异之和。
假设 max(s) 表示任何子集“s”中的最大值，而 min(s) 表示集合“s”中的最小值。我们需要找到所有可能子集的 max(s)-min(s) 之和。

例子：

Input : arr[] = {1, 2, 3}
Output : result = 6

Explanation : 
All possible subset and for each subset s,
max(s)-min(s) are as :
SUBSET    |  max(s) | min(s) | max(s)-min(s)
{1, 2}    |  2      |  1     |   1
{1, 3}    |  3      |  1     |   2
{2, 3}    |  3      |  2     |   1
{1, 2, 3} |  3      |  1     |   2
Total Difference sum = 6
Note : max(s) - min(s) for all subset with 
single element must be zero.

Input : arr[] = {1, 2, 2}
Output : result = 3

Explanation : 
All possible subset and for each subset s,
max(s)-min(s) are as :
  SUBSET  |  max(s) | min(s)| max(s)-min(s)
  {1, 2}  |  2      |  1    |   1
  {1, 2}  |  2      |  1    |   1
  {2, 2}  |  2      |  2    |   0
{1, 2, 2} |  2      |  1    |   1
Total Difference sum = 3

基本方法：分别计算每个子集的最大元素之和，以及每个子集的最小元素之和，然后从最大值中减去最小和，得到答案。每个子集的最大/最小元素之和可以通过迭代每个子集的元素来轻松计算。但是由于我们必须遍历所有子集，这种方法的时间复杂度是指数 O(n2^n)。
有效的方法：
由于我们必须计算每个子集的最大元素之和，这里分别计算每个子集的最小元素之和是执行此计算的有效方法。
所有子集的最小元素之和：
假设 arr[] 的非降序元素是 {a1,a2,...,an}。现在，我们可以将 arr[] 的子集划分为以下类别：

包含元素 a1 的子集：这些子集可以通过取 {a2,a3,...,an} 的任何子集然后将 a1 添加到其中来获得。这样的子集的数量将是 2 ^n-1 ，并且它们都具有 a1 作为它们的最小元素。
不包含元素 a1 但包含 a2 的子集：这些子集可以通过取 {a3, a4,…,an} 的任何子集，然后将 a2 添加到其中来获得。这样的子集的数量将是 2 ^n-2 ，并且它们都具有 a2 作为它们的最小元素。
……
不包含元素 a1, a2,…, ai-1 但包含 ai 的子集：这些子集可以通过取 {ai+1,ai+2,…, an} 的任何子集，然后将 ai 添加到其中来获得。这样的子集的数量将是 2 ⁿⁱ ，并且它们都以 ai 作为它们的最小元素。

可以看出，上述迭代是完整的，即每个子集只考虑一次。因此，所有子集的最小元素之和将是：
min_sum = a1*2 ^n-1 + a2*2 ^n-2 + … + an*2 ⁰
借助霍纳方法，可以在线性时间内轻松计算出这个总和……
类似地，我们可以计算 arr[] 的所有子集的最大元素之和。唯一的区别是我们需要以非递增的顺序迭代 arr[] 的元素。
注意：我们可能有一个很大的答案，所以我们必须用 mod 10^9 +7 来计算答案。

C++

// CPP for finding max min difference
// from all subset of given set
#include 
using namespace std;
  
const long long int MOD = 1000000007;
  
// function for sum of max min difference 
int maxMin (int arr[], int n) 
{
    // sort all numbers
    sort(arr, arr + n);
      
    // iterate over array and with help of 
    // horner's rule calc max_sum and min_sum
    long long int min_sum = 0, max_sum = 0;
    for (int i = 0; i < n; i++)
    {
        max_sum = 2 * max_sum + arr[n-1-i];
        max_sum %= MOD;
        min_sum = 2 * min_sum + arr[i];
        min_sum %= MOD;
    }
  
    return (max_sum - min_sum + MOD) % MOD;
}
  
// Driver Code
int main()
{
    int arr[] = {1, 2, 3, 4};
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << maxMin(arr,n);
    return 0;
}

Java

// JAVA Code for Find the sum of maximum 
// difference possible from all subset 
// of a given array.
import java.util.*;
  
class GFG {
      
    public static int MOD = 1000000007;
      
    // function for sum of max min difference 
    public static long maxMin (int arr[], int n) 
    {
        // sort all numbers
        Arrays.sort(arr);
          
        // iterate over array and with help of 
        // horner's rule calc max_sum and min_sum
        long min_sum = 0, max_sum = 0;
        for (int i = 0; i < n; i++)
        {
            max_sum = 2 * max_sum + arr[n - 1 - i];
            max_sum %= MOD;
            min_sum = 2 * min_sum + arr[i];
            min_sum %= MOD;
        }
      
        return (max_sum - min_sum + MOD)%MOD;
    }
      
    // Driver Code
    public static void main(String[] args) 
    {
            int arr[] = {1, 2, 3, 4};
            int n = arr.length;
            System.out.println(maxMin(arr, n));
    }
}
  
// This code is contributed by Arnav Kr. Mandal.

Python3

# python for finding max min difference
#from all subset of given set
  
MOD = 1000000007;
  
# function for sum of max min difference 
def maxMin (arr,n):
      
    # sort all numbers
    arr.sort()
      
    # iterate over array and with help of 
    # horner's rule calc max_sum and min_sum
    min_sum = 0
    max_sum = 0
    for i in range(0,n):
          
        max_sum = 2 * max_sum + arr[n-1-i];
        max_sum %= MOD;
        min_sum = 2 * min_sum + arr[i];
        min_sum %= MOD;
      
    return (max_sum - min_sum + MOD) % MOD;
  
# Driver Code
arr = [1, 2, 3, 4]
n = len(arr)
print( maxMin(arr, n))
  
# This code is contributed by Sam007.

C#

// C# Code to Find the sum of maximum 
// difference possible from all subset 
// of a given array.
using System;
  
class GFG {
      
    public static int MOD = 1000000007;
      
    // function for sum of max min difference 
    public static long maxMin (int []arr, int n) 
    {
        // sort all numbers
        Array.Sort(arr);
          
        // iterate over array and with help of 
        // horner's rule calc max_sum and min_sum
        long min_sum = 0, max_sum = 0;
        for (int i = 0; i < n; i++)
        {
            max_sum = 2 * max_sum + arr[n - 1 - i];
            max_sum %= MOD;
            min_sum = 2 * min_sum + arr[i];
            min_sum %= MOD;
        }
      
        return (max_sum - min_sum + MOD) % MOD;
    }
      
    // Driver Code
    public static void Main() 
    {
            int []arr = {1, 2, 3, 4};
            int n = arr.Length;
            Console.Write(maxMin(arr, n));    
    }
}
  
// This code is contributed by nitin mittal

PHP

Javascript

输出：