📺 Info Siaran: dsa/minimize xor with power of to make elements in range equal

Given an array A[] of size N (0 ? A[i] ? 10⁹). The following operations can be performed on the array.

Choose a random integer X such that it is a power of 2.
Choose an index from 0 to N-1 and replace A[i] with A[i] ? X, where, ? represent the binary XOR operation.

The task is to answer Q queries where each query is of type [l, r] denoting the range from l^th to r^th index (both inclusive) and you have to find the minimum operations to make all the elements in the range equal.

Examples:

Input: N = 4, A[] = {2, 3, 1, 7}, Q = 1, query[]= {{0, 2}}
Output: 2
Explanation: The operations are as follows:
Choose X = 1 and A[0] = 2. Array becomes {3, 3, 1, 7}.
Choose X = 2 and A[2] = 1. Array becomes {3, 3, 3, 7}.
Hence the subarray between index 0 and 2 becomes equal.

Approach:

In one operation we can change only one bit of a single element because X is power of 2. So the task is to find the number of bits that need to be set between the given ranges.

Follow the steps mentioned below to implement the idea:

Try to solve this problem by considering each bit position separately as all the elements are equal at the end and have the same binary representation.
For a given query with range [l, r], total number of elements n = (r-l+1).
- Calculate the number of set bits in each position in the range l^th to r^th.
  - Then we have two options either make this bit position 1 or 0 in the final binary representation
  - Let x be the number of set bits for an i^th position. Then the minimum number of operations for making this bit equal in all elements in the given range is minimum(x, n - x).
- Thus, the answer for the given query will be the summation of minimum(x, n - x) over 1^st to 32nd.

Below is the implementation of the above approach.

C++

// C++ code to implement the approach

#include <bits/stdc++.h>
using namespace std;

// Function to calculate minimum operation
vector<int> MinimumOperations(int N, int A[], int Q,
                              int query[][2])
{
    // Vector to store ans of all queries
    vector<int> ans;

    // Loop to calculate the minimum number
    // of operations for each query
    for (int i = 0; i < Q; i++) {
        int l = query[i][0];
        int r = query[i][1];

        // To store answer for current query
        int y = 0;
        int n = (r - l + 1);

        // loop for calculating at
        // number of setbits from
        // 0th to 31st bit
        for (int j = 0; j < 32; j++) {
            int setbitcount = 0;
            for (int i = l; i <= r; i++) {
                int mask = pow(2, j);
                if (A[i] & mask)
                    setbitcount++;
            }
            y += min(setbitcount, n - setbitcount);
        }

        ans.push_back(y);
    }
    return ans;
}

// Driver code
int main()
{
    int A[] = { 2, 3, 1, 7 };
    int N = sizeof(A) / sizeof(A[0]);
    int query[][2] = { { 0, 2 } };

    // Function call
    vector<int> v = MinimumOperations(N, A, 1, query);
    for (int i = 0; i < v.size(); i++) {
        cout << v[i] << " ";
    }
    return 0;
}

Java

// Java code to implement the approach

import java.io.*;
import java.util.*;

class GFG {

  // Function to calculate minimum operation
  static List<Integer>
    MinimumOperations(int N, int[] A, int Q, int[][] query)
  {
    // arraylist to store ans of all queries
    List<Integer> ans = new ArrayList<Integer>();

    // Loop to calculate the minimum number
    // of operations for each query
    for (int i = 0; i < Q; i++) {
      int l = query[i][0];
      int r = query[i][1];

      // To store answer for current query
      int y = 0;
      int n = (r - l + 1);

      // loop for calculating at
      // number of setbits from
      // 0th to 31st bit
      for (int j = 0; j < 32; j++) {
        int setbitcount = 0;
        for (int k = l; k <= r; k++) {
          int mask = (int)Math.pow(2, j);
          if ((A[k] & mask) == 1) {
            setbitcount++;
          }
        }
        y += Math.min(setbitcount, n - setbitcount);
      }
      ans.add(y);
    }
    return ans;
  }

  public static void main(String[] args)
  {
    int[] A = { 2, 3, 1, 7 };
    int N = A.length;
    int[][] query = { { 0, 2 } };

    // Function call
    List<Integer> v = MinimumOperations(N, A, 1, query);
    for (int i = 0; i < v.size(); i++) {
      System.out.print(v.get(i) + " ");
    }
  }
}

// This code is contributed by lokeshmvs21.

Python3

# Python code to implement the approach

# Function to calculate minimum operation
def MinimumOperations(N, A, Q, query):
    # List to store ans of all queries
    ans = []
    
    # Loop to calculate the minimum number
    # of operations for each query
    for i in range(Q):
        l = query[i][0]
        r = query[i][1]
        
        # To store answer for current query
        y = 0
        n = r - l + 1
        
        # loop for calculating at
        # number of setbits from
        # 0th to 31st bit
        for j in range(32):
            setbitcount = 0
            for i in range(l, r + 1):
                mask = 2**j
                if(A[i]&mask):
                    setbitcount = setbitcount + 1
            y=y+min(setbitcount, n - setbitcount)
        
        ans.append(y)
    
    return ans

# Driver code

A = [2, 3, 1, 7]
N = len(A)
query = [[0, 2]]

# Function call
v=MinimumOperations(N, A, 1, query)
for i in range(len(v)):
    print(v[i], end=" ")

# This code is contributed by Pushpesh Raj.

// C# code addition
using System;

public class GFG {

  // Function to calculate minimum operation
  public static int[] MinimumOperations(int N, int[] A,
                                        int Q,
                                        int[, ] query)
  {
    // Vector to store ans of all queries
    int[] ans = new int[Q];

    // Loop to calculate the minimum number
    // of operations for each query
    for (int i = 0; i < Q; i++) {
      int l = query[i, 0];
      int r = query[i, 1];

      // To store answer for current query
      int y = 0;
      int n = (r - l + 1);

      // loop for calculating at
      // number of setbits from
      // 0th to 31st bit
      for (int j = 0; j < 32; j++) {
        int setbitcount = 0;
        for (int k = l; k <= r; k++) {
          int mask = (int)Math.Pow(2, j);
          if ((A[k] & mask) == 0)
            setbitcount++;
        }
        y += Math.Min(setbitcount, n - setbitcount);
      }

      ans[i] = y;
    }
    return ans;
  }

  static public void Main()
  {

    int[] A = { 2, 3, 1, 7 };

    int N = A.Length;
    int[, ] query = { { 0, 2 } };

    // Function call
    int[] v = MinimumOperations(N, A, 1, query);
    for (int i = 0; i < v.Length; i++) {
      Console.WriteLine(v[i]);
    }
  }
}

// This code is contributed by ksam24000

JavaScript

    // JavaScript code for the above approach

    // Function to calculate minimum operation
    function MinimumOperations(N, A, Q,
      query) {
      // Vector to store ans of all queries
      let ans = [];

      // Loop to calculate the minimum number
      // of operations for each query
      for (let i = 0; i < Q; i++) {
        let l = query[i][0];
        let r = query[i][1];

        // To store answer for current query
        let y = 0;
        let n = (r - l + 1);

        // loop for calculating at
        // number of setbits from
        // 0th to 31st bit
        for (let j = 0; j < 32; j++) {
          let setbitcount = 0;
          for (let i = l; i <= r; i++) {
            let mask = Math.pow(2, j);
            if (A[i] & mask)
              setbitcount++;
          }
          y += Math.min(setbitcount, n - setbitcount);
        }

        ans.push(y);
      }
      return ans;
    }

    // Driver code

    let A = [2, 3, 1, 7];
    let N = A.length;
    let query = [[0, 2]];

    // Function call
    let v = MinimumOperations(N, A, 1, query);
    for (let i = 0; i < v.length; i++) {
      console.log(v[i] + " ");
    }

 // This code is contributed by Potta Lokesh

Output

Time Complexity: O(Q*N*32) For every query, we are iterating all the elements in the range [l, r] and we are iterating 32 times.
Auxiliary Space: O(Q)

Efficient Approach using Prefix sum:

The above approach can be optimized by creating a prefix array (say dp[][]) where dp[i][j] will store the total number of setbits at j^th position till i^th index.