删除元素以最大化算术平均值的方法数量

给定一个数组arr [] ，任务是找到从数组中删除元素的方法，以使剩余数组的算术平均值最大。

例子：

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

Remove elements at indices:
{ 0, 1, 2 }
{ 0, 2, 3 }
{ 0, 2 }

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

方法：只有最大元素保留在数组中时，才能使数组的算术平均值最大。

现在考虑数组arr [] = {3，3，3，3}
我们只需要确保在除去其他元素之后，至少有一个最大元素实例保留在数组中。这将保证算术平均值的最大化。因此，我们需要从上述数组中删除最多3个元素。最多删除3个元素的方式数目：

1. 零元素已删除。路数= 1。
2. 删除了一个元素。路数= 4。
3. 删除了两个元素。路数= 6。
4. 删除了三个元素。路数= 4。

因此总计= 1 + 4 + 6 + 4 = 15 = 2 ⁴ – 1。

现在考虑数组= {1，4，3，2，3，4，4}
在排序时，数组变为= {1，2，3，3，4，4，4}。在这种情况下，除了4之外，还有其他元素。我们最多可以删除2个4实例，而当删除这些实例时，应始终将其他元素(不是4)一起删除。因此，最多移除2个实例4的方法数量将保持不变。

删除元素的各种方法：
{1，2，3，3}
{1，2，3，3，4}
{1，2，3，3，4}
{1，2，3，3，4}
{1，2，3，3，4，4}
{1，2，3，3，4，4}
{1，2，3，3，4，4}

因此，答案是2^{个最大元素数}– 1。

下面是上述方法的实现。

C++

// C++ implementation of the above approach
#include 
  
#define ll long long
  
using namespace std;
const int mod = 1000000007;
  
// Function to compute a^n
ll power(ll a, ll n)
{
    if (n == 0)
        return 1;
  
    ll p = power(a, n / 2) % mod;
    p = (p * p) % mod;
    if (n & 1)
        p = (p * a) % mod;
  
    return p;
}
  
// Function to return number of ways to maximize arithmetic mean
ll numberOfWays(int* arr, int n)
{
  
    int max_count = 0;
    int max_value = *max_element(arr, arr + n);
    for (int i = 0; i < n; i++) {
        if (arr[i] == max_value)
            max_count++;
    }
    return (power(2, max_count) - 1 + mod) % mod;
}
  
// Driver code
int main()
{
    int arr[] = { 1, 2, 1, 2 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << numberOfWays(arr, n);
    return 0;
}

Java

// Java implementation of the above approach
import java.util.Arrays;
  
class GFG
{
      
static int mod = 1000000007;
  
// Function to compute a^n
static int power(int a, int n)
{
    if (n == 0)
        return 1;
  
    int p = power(a, n / 2) % mod;
    p = (p * p) % mod;
    if ((n & 1) > 0)
        p = (p * a) % mod;
  
    return p;
}
  
// Function to return number of 
// ways to maximize arithmetic mean
static int numberOfWays(int []arr, int n)
{
  
    int max_count = 0;
    int max_value = Arrays.stream(arr).max().getAsInt();
    for (int i = 0; i < n; i++) 
    {
        if (arr[i] == max_value)
            max_count++;
    }
    return (power(2, max_count) - 1 + mod) % mod;
}
  
// Driver code
public static void main (String[] args) 
{
    int []arr = { 1, 2, 1, 2 };
    int n = arr.length;
    System.out.println(numberOfWays(arr, n));
}
}
  
// This code is contributed by mits

Python3

# Python3 implementation of the 
# above approach 
  
mod = 1000000007; 
  
# Function to compute a^n 
def power(a, n) : 
      
    if (n == 0) :
        return 1; 
  
    p = power(a, n // 2) % mod; 
    p = (p * p) % mod; 
    if (n & 1) :
        p = (p * a) % mod; 
  
    return p; 
  
# Function to return number of ways 
# to maximize arithmetic mean 
def numberOfWays(arr, n) :
  
    max_count = 0; 
    max_value = max(arr) 
      
    for i in range(n) :
        if (arr[i] == max_value) :
            max_count += 1; 
              
    return (power(2, max_count) - 1 + mod) % mod; 
  
# Driver code 
if __name__ == "__main__" : 
  
    arr = [ 1, 2, 1, 2 ]; 
    n = len(arr) ;
      
    print(numberOfWays(arr, n)); 
  
# This code is contributed by Ryuga

C#

// C# implementation of the above approach
using System;
using System.Linq;
  
class GFG
{
      
static int mod = 1000000007;
  
// Function to compute a^n
static int power(int a, int n)
{
    if (n == 0)
        return 1;
  
    int p = power(a, n / 2) % mod;
    p = (p * p) % mod;
    if ((n & 1)>0)
        p = (p * a) % mod;
  
    return p;
}
  
// Function to return number of 
// ways to maximize arithmetic mean
static int numberOfWays(int []arr, int n)
{
  
    int max_count = 0;
    int max_value = arr.Max();
    for (int i = 0; i < n; i++) 
    {
        if (arr[i] == max_value)
            max_count++;
    }
    return (power(2, max_count) - 1 + mod) % mod;
}
  
// Driver code
static void Main()
{
    int []arr = { 1, 2, 1, 2 };
    int n = arr.Length;
    Console.WriteLine(numberOfWays(arr, n));
}
}
  
// This code is contributed by mits

PHP

 0) 
    { 
        // If y is odd, multiply 
        // x with result 
        if ($y & 1) 
            $res = ($res * $x) % $p; 
  
        // y must be even now 
          
        // y = $y/2 
        $y = $y >> 1; 
        $x = ($x * $x) % $p; 
    } 
    return $res; 
} 
  
// Function to return number of ways 
// to maximize arithmetic mean 
function numberOfWays($arr, $n) 
{ 
    $mod = 1000000007; 
    $max_count = 0; 
    $max_value = $arr[0]; 
    for($i = 0; $i < $n; $i++)
    if($max_value < $arr[$i])
        $max_value = $arr[$i];
      
    for ($i = 0; $i < $n; $i++)
    { 
        if ($arr[$i] == $max_value) 
            $max_count++; 
    } 
    return (power(2, $max_count, 
                     $mod) - 1 + $mod) % $mod; 
} 
  
// Driver code 
$arr = array( 1, 2, 1, 2 ); 
$n = 4; 
echo numberOfWays($arr, $n); 
  
// This code is contributed 
// by Arnab Kundu
?>

输出：

3