通过用它们的按位 AND 和按位 OR 替换对来最大化可能的数组元素的平方和

给定一个由N 个整数组成的数组arr[] ，任务是通过执行以下操作从给定数组中找到可能的数组元素的最大平方和：

• 选择任意一对数组元素(arr[i], arr[j])
• 更换改编[i]发表改编[i]和常用3 [J]。
• 将arr[j]替换为arr[i]或arr[j] 。

例子：

Input: arr[] = {1, 3, 5}
Output: 51
Explanation:
For the pair (arr[1], arr[2]), perform the following operations:
Replace 3 with 3 AND 5, which is equal to 1.
Replace 5 with 2 OR 5, which is equal to 7.
The modified array obtained after the above steps is {1, 1, 7}.
Therefore, the maximized sum of the squares can be calculated by 1 * 1 + 1 * 1 + 7 * 7 = 51.

Input: arr[] = {8, 9, 9, 1}
Output: 243

方法：这个想法是观察如果 x 和 y 是 2 个选定的元素，那么让z = x AND y , w = x OR y其中x + y = z + w 。

• 如果x ≤ y ，不失一般性，显然， z ≤ w 。因此，将表达式重写为x + y = (x – d) + (y + d)

Old sum of squares = M = x² + y²
New sum of squares = N = (x – d)² + (y – d)², d > 0
Difference = N – M = 2d(y + d – x), d > 0 

• 如果d > 0 ，则差异为正。因此，我们成功地增加了总平方和。上述观察是由于较大数的平方大于较小数的平方和的事实。
• 将给定的整数转换为二进制形式后，我们观察到以下情况：

x = 3 =  0 1 1
y = 5 =  1 0 1
z = 1 =  0 0 1
w = 7 = 1 1 1

• x + y 中的总设置位 = 2 + 2 = 4，z + w 中的总设置位 = 1 + 3 = 4。因此，执行此操作后保留了总设置位。现在的想法是找出z和w 。

For Example: arr[] = {5, 2, 3, 4, 5, 6, 7}

1 0 1 = 5
0 1 0 = 2
0 1 1 = 3
1 0 0 = 4
1 0 1 = 5
1 1 0 = 6
1 1 1 = 7
———-
5 4 4 (sum of set bits)
Now, sum up the squares of these numbers. 
 

• 因此，对每个位位置 1 到 20 进行迭代，存储该索引中的总位数。
• 然后在构造一个数字时，从每个索引中一次取 1 位。
• 得到数字后，将数字的平方加到答案中。
• 在上述步骤之后打印答案的值。

以下是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Stores the maximum value
int ans = 0;
 
int binary[31];
 
// Function to find the maximum sum
// of squares for each element of the
// array after updates
void findMaximumSum(
    const vector& arr, int n)
{
    // Update the binary bit count at
    // corresponding indices for
    // each element
    for (auto x : arr) {
 
        int idx = 0;
 
        // Iterate all set bits
        while (x) {
 
            // If current bit is set
            if (x & 1)
                binary[idx]++;
            x >>= 1;
            idx++;
        }
    }
 
    // Construct number according
    // to the above defined rule
    for (int i = 0; i < n; ++i) {
 
        int total = 0;
 
        // Traverse each binary bit
        for (int j = 0; j < 21; ++j) {
 
            // If current bit is set
            if (binary[j] > 0) {
                total += pow(2, j);
                binary[j]--;
            }
        }
 
        // Square the constructed number
        ans += total * total;
    }
 
    // Return the answer
    cout << ans << endl;
}
 
// Driver Code
int main()
{
    // Given array arr[]
    vector arr = { 8, 9, 9, 1 };
 
    int N = arr.size();
 
    // Function call
    findMaximumSum(arr, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Stores the maximum value
static int ans = 0;
 
static int []binary = new int[31];
 
// Function to find the maximum sum
// of squares for each element of the
// array after updates
static void findMaximumSum(int []arr, int n)
{
     
    // Update the binary bit count at
    // corresponding indices for
    // each element
    for(int x : arr)
    {
        int idx = 0;
 
        // Iterate all set bits
        while (x > 0)
        {
             
            // If current bit is set
            if ((x & 1) > 0)
                binary[idx]++;
                 
            x >>= 1;
            idx++;
        }
    }
 
    // Connumber according
    // to the above defined rule
    for(int i = 0; i < n; ++i)
    {
        int total = 0;
 
        // Traverse each binary bit
        for(int j = 0; j < 21; ++j)
        {
             
            // If current bit is set
            if (binary[j] > 0)
            {
                total += Math.pow(2, j);
                binary[j]--;
            }
        }
 
        // Square the constructed number
        ans += total * total;
    }
 
    // Return the answer
    System.out.print(ans + "\n");
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given array arr[]
   int[] arr = { 8, 9, 9, 1 };
 
    int N = arr.length;
 
    // Function call
    findMaximumSum(arr, N);
}
}
 
// This code is contributed by Amit Katiyar

Python3

# Python3 program for the above approach
import math
 
binary = [0] * 31
  
# Function to find the maximum sum
# of squares for each element of the
# array after updates
def findMaximumSum(arr, n):
     
    # Stores the maximum value
    ans = 0
 
    # Update the binary bit count at
    # corresponding indices for
    # each element
    for x in arr:
        idx = 0
  
        # Iterate all set bits
        while (x):
  
            # If current bit is set
            if (x & 1):
                binary[idx] += 1
                 
            x >>= 1
            idx += 1
         
    # Construct number according
    # to the above defined rule
    for i in range(n):
        total = 0
  
        # Traverse each binary bit
        for j in range(21):
  
            # If current bit is set
            if (binary[j] > 0):
                total += int(math.pow(2, j))
                binary[j] -= 1
             
        # Square the constructed number
        ans += total * total
     
    # Return the answer
    print(ans)
 
# Driver Code
 
# Given array arr[]
arr = [ 8, 9, 9, 1 ]
  
N = len(arr)
  
# Function call
findMaximumSum(arr, N)
 
# This code is contributed by code_hunt

C#

// C# program for the
// above approach
using System;
class GFG{
 
// Stores the maximum
// value
static int ans = 0;
 
static int []binary =
             new int[31];
 
// Function to find the maximum
// sum of squares for each element
// of the array after updates
static void findMaximumSum(int []arr,
                           int n)
{
  // Update the binary bit
  // count at corresponding
  // indices for each element
  for(int i = 0; i < arr.Length; i++)
  {
    int idx = 0;
 
    // Iterate all set bits
    while (arr[i] > 0)
    {
      // If current bit is set
      if ((arr[i] & 1) > 0)
        binary[idx]++;
 
      arr[i] >>= 1;
      idx++;
    }
  }
 
  // Connumber according
  // to the above defined rule
  for(int i = 0; i < n; ++i)
  {
    int total = 0;
 
    // Traverse each binary bit
    for(int j = 0; j < 21; ++j)
    {
      // If current bit is set
      if (binary[j] > 0)
      {
        total += (int)Math.Pow(2, j);
        binary[j]--;
      }
    }
 
    // Square the constructed
    // number
    ans += total * total;
  }
 
  // Return the answer
  Console.Write(ans + "\n");
}
 
// Driver Code
public static void Main(String[] args)
{
  // Given array []arr
  int[] arr = {8, 9, 9, 1};
 
  int N = arr.Length;
 
  // Function call
  findMaximumSum(arr, N);
}
}
 
// This code is contributed by 29AjayKumar

Javascript

 
// Javascript program for the above approach
 
// Stores the maximum value
var ans = 0;
 
var binary = Array(31).fill(0);
 
// Function to find the maximum sum
// of squares for each element of the
// array after updates
function findMaximumSum(arr, n)
{
    // Update the binary bit count at
    // corresponding indices for
    // each element
    var i,j;
    for (i= 0;i<arr.length;i++) {
        var x = arr[i];
        var idx = 0;
 
        // Iterate all set bits
        while (x) {
 
            // If current bit is set
            if (x & 1)
                binary[idx]++;
            x >>= 1;
            idx++;
        }
    }
 
    // Construct number according
    // to the above defined rule
    for (i = 0; i < n; ++i) {
 
        var total = 0;
 
        // Traverse each binary bit
        for (j = 0; j < 21; ++j) {
 
            // If current bit is set
            if (binary[j] > 0) {
                total += Math.pow(2, j);
                binary[j]--;
            }
        }
 
        // Square the constructed number
        ans += total * total;
    }
 
    // Return the answer
    document.write(ans);
}
 
// Driver Code
    // Given array arr[]
    var arr = [8, 9, 9, 1];
 
    var N = arr.length;
 
    // Function call
    findMaximumSum(arr, N);
 

输出

243

时间复杂度： O(N log ₂ A)，其中 A 是数组的最大元素。
辅助空间： O(1)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live