Given an array arr[] consisting of N positive integers, the task is to find the maximum sum of Bitwise AND of same-indexed elements of permutation of the first N natural numbers and the array arr[].
Examples:
Input: arr[] = {4, 2, 3, 6}
Output: 5
Explanation: Consider the permutation {1, 0, 3, 2}. Sum of Bitwise AND of the above permutation and the given array = 1 & 4 + 0 & 2 + 3 & 3 + 2 & 6 = 0 + 0 + 3 + 2 = 5, which is maximum among all permutations.Input: arr[] = {3, 4, 1, 0, 5}
Output: 8
Approach: The idea to solve the given problem is to generate all permutations of the first N natural numbers and calculate the sum of the Bitwise AND of the generated permutation with the array arr[]. After checking for each permutation, print the maximum value of the sum of Bitwise AND obtained.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to calculate sum of // Bitwise AND of same indexed // elements of the arrays p[] and arr[] int calcScore(vector< int > p, int arr[], int N)
{ // Stores the resultant sum
int ans = 0;
// Traverse the array
for ( int i = 0; i < N; i++) {
// Update sum of Bitwise AND
ans += (p[i] & arr[i]);
}
// Return the value obtained
return ans;
} // Function to generate all permutations // and calculate the maximum sum of Bitwise // AND of same indexed elements present in // any permutation and an array arr[] int getMaxUtil(vector< int > p, int arr[], int ans,
bool chosen[], int N)
{ // If the size of the array is N
if (p.size() == N) {
// Calculate cost of permutation
ans = max(ans, calcScore(p, arr, N));
return ans;
}
// Generate all permutations
for ( int i = 0; i < N; i++) {
if (chosen[i]) {
continue ;
}
// Update chosen[i]
chosen[i] = true ;
// Update the permutation p[]
p.push_back(i);
// Generate remaining permutations
ans = getMaxUtil(p, arr, ans, chosen, N);
chosen[i] = false ;
p.pop_back();
}
// Return the resultant sum
return ans;
} // Function to find the maximum sum of Bitwise // AND of same indexed elements in a permutation // of first N natural numbers and arr[] void getMax( int arr[], int N)
{ // Stores the resultant maximum sum
int ans = 0;
bool chosen[N];
for ( int i = 0; i < N; i++)
chosen[i] = false ;
// Stores the generated permutation P
vector< int > p;
// Function call to store result
int res = getMaxUtil(p, arr, ans, chosen, N);
// Print the result
cout << res;
} // Driven Program int main()
{ int arr[] = { 4, 2, 3, 6 };
int N = sizeof (arr) / sizeof (arr[0]);
// Function call
getMax(arr, N);
return 0;
} // This code is contributed by Kingash. |
// Java program for the above approach import java.io.*;
import java.lang.*;
import java.util.*;
class GFG {
// Function to calculate sum of
// Bitwise AND of same indexed
// elements of the arrays p[] and arr[]
static int calcScore(ArrayList<Integer> p, int arr[])
{
// Stores the resultant sum
int ans = 0 ;
// Traverse the array
for ( int i = 0 ; i < arr.length; i++) {
// Update sum of Bitwise AND
ans += (p.get(i) & arr[i]);
}
// Return the value obtained
return ans;
}
// Function to generate all permutations
// and calculate the maximum sum of Bitwise
// AND of same indexed elements present in
// any permutation and an array arr[]
static int getMaxUtil(ArrayList<Integer> p, int arr[],
int ans, boolean chosen[], int N)
{
// If the size of the array is N
if (p.size() == N) {
// Calculate cost of permutation
ans = Math.max(ans, calcScore(p, arr));
return ans;
}
// Generate all permutations
for ( int i = 0 ; i < N; i++) {
if (chosen[i]) {
continue ;
}
// Update chosen[i]
chosen[i] = true ;
// Update the permutation p[]
p.add(i);
// Generate remaining permutations
ans = getMaxUtil(p, arr, ans, chosen, N);
chosen[i] = false ;
p.remove(p.size() - 1 );
}
// Return the resultant sum
return ans;
}
// Function to find the maximum sum of Bitwise
// AND of same indexed elements in a permutation
// of first N natural numbers and arr[]
static void getMax( int arr[], int N)
{
// Stores the resultant maximum sum
int ans = 0 ;
boolean chosen[] = new boolean [N];
// Stores the generated permutation P
ArrayList<Integer> p = new ArrayList<>();
// Function call to store result
int res = getMaxUtil(p, arr, ans, chosen, N);
// Print the result
System.out.println(res);
}
// Driver Code
public static void main(String[] args)
{
int arr[] = { 4 , 2 , 3 , 6 };
int N = arr.length;
// Function Call
getMax(arr, N);
}
} // This code is contributed by Kingash. |
# Python3 program for the above approach # Function to calculate sum of # Bitwise AND of same indexed # elements of the arrays p[] and arr[] def calcScore(p, arr):
# Stores the resultant sum
ans = 0
# Traverse the array
for i in range ( len (arr)):
# Update sum of Bitwise AND
ans + = (p[i] & arr[i])
# Return the value obtained
return ans
# Function to generate all permutations # and calculate the maximum sum of Bitwise # AND of same indexed elements present in # any permutation and an array arr[] def getMaxUtil(p, arr, ans, chosen, N):
# If the size of the array is N
if len (p) = = N:
# Calculate cost of permutation
ans = max (ans, calcScore(p, arr))
return ans
# Generate all permutations
for i in range (N):
if chosen[i]:
continue
# Update chosen[i]
chosen[i] = True
# Update the permutation p[]
p.append(i)
# Generate remaining permutations
ans = getMaxUtil(p, arr, ans, chosen, N)
chosen[i] = False
p.pop()
# Return the resultant sum
return ans
# Function to find the maximum sum of Bitwise # AND of same indexed elements in a permutation # of first N natural numbers and arr[] def getMax(arr, N):
# Stores the resultant maximum sum
ans = 0
chosen = [ False for i in range (N)]
# Stores the generated permutation P
p = []
# Function call to store result
res = getMaxUtil(p, arr, ans, chosen, N)
# Print the result
print (res)
# Driver Code if __name__ = = '__main__' :
# Given array
arr = [ 4 , 2 , 3 , 6 ]
N = len (arr)
# Function Call
getMax(arr, N)
|
// C# program for the above approach using System;
using System.Collections.Generic;
class GFG{
// Function to calculate sum of // Bitwise AND of same indexed // elements of the arrays p[] and arr[] static int calcScore(List< int > p, int [] arr)
{ // Stores the resultant sum
int ans = 0;
// Traverse the array
for ( int i = 0; i < arr.Length; i++)
{
// Update sum of Bitwise AND
ans += (p[i] & arr[i]);
}
// Return the value obtained
return ans;
} // Function to generate all permutations // and calculate the maximum sum of Bitwise // AND of same indexed elements present in // any permutation and an array arr[] static int getMaxUtil(List< int > p, int [] arr,
int ans, bool [] chosen,
int N)
{ // If the size of the array is N
if (p.Count == N)
{
// Calculate cost of permutation
ans = Math.Max(ans, calcScore(p, arr));
return ans;
}
// Generate all permutations
for ( int i = 0; i < N; i++)
{
if (chosen[i])
{
continue ;
}
// Update chosen[i]
chosen[i] = true ;
// Update the permutation p[]
p.Add(i);
// Generate remaining permutations
ans = getMaxUtil(p, arr, ans, chosen, N);
chosen[i] = false ;
p.Remove(p.Count - 1);
}
// Return the resultant sum
return ans;
} // Function to find the maximum sum of Bitwise // AND of same indexed elements in a permutation // of first N natural numbers and arr[] static void getMax( int [] arr, int N)
{ // Stores the resultant maximum sum
int ans = 0;
bool [] chosen = new bool [N];
// Stores the generated permutation P
List< int > p = new List< int >();
// Function call to store result
int res = getMaxUtil(p, arr, ans, chosen, N);
// Print the result
Console.Write(res);
} // Driver Code public static void Main()
{ int [] arr = { 4, 2, 3, 6 };
int N = arr.Length;
// Function Call
getMax(arr, N);
} } // This code is contributed by sanjoy_62 |
<script> // Javascript program for the above approach // Function to calculate sum of // Bitwise AND of same indexed // elements of the arrays p[] and arr[] function calcScore(p, arr, N)
{ // Stores the resultant sum
var ans = 0;
// Traverse the array
for ( var i = 0; i < N; i++) {
// Update sum of Bitwise AND
ans += (p[i] & arr[i]);
}
// Return the value obtained
return ans;
} // Function to generate all permutations // and calculate the maximum sum of Bitwise // AND of same indexed elements present in // any permutation and an array arr[] function getMaxUtil(p, arr, ans, chosen, N)
{ // If the size of the array is N
if (p.length == N) {
// Calculate cost of permutation
ans = Math.max(ans, calcScore(p, arr, N));
return ans;
}
// Generate all permutations
for ( var i = 0; i < N; i++) {
if (chosen[i]) {
continue ;
}
// Update chosen[i]
chosen[i] = true ;
// Update the permutation p[]
p.push(i);
// Generate remaining permutations
ans = getMaxUtil(p, arr, ans, chosen, N);
chosen[i] = false ;
p.pop();
}
// Return the resultant sum
return ans;
} // Function to find the maximum sum of Bitwise // AND of same indexed elements in a permutation // of first N natural numbers and arr[] function getMax(arr, N)
{ // Stores the resultant maximum sum
var ans = 0;
var chosen = Array(N).fill( false );
// Stores the generated permutation P
var p = [];
// Function call to store result
var res = getMaxUtil(p, arr, ans, chosen, N);
// Print the result
document.write( res);
} // Driven Program var arr = [ 4, 2, 3, 6 ];
var N = arr.length;
// Function call getMax(arr, N); </script> |
5
Time Complexity: O(N*N!)
Auxiliary Space: O(N)