Number of ordered pairs such that (Ai & Aj) = 0
Last Updated :
02 Feb, 2023
Given an array A[] of n integers, find out the number of ordered pairs such that Ai&Aj is zero, where 0<=(i,j)<n. Consider (i, j) and (j, i) to be different.
Constraints:
1<=n<=104
1<=Ai<=104
Examples:
Input : A[] = {3, 4, 2}
Output : 4
Explanation : The pairs are (3, 4) and (4, 2) which are
counted as 2 as (4, 3) and (2, 4) are considered different.
Input : A[]={5, 4, 1, 6}
Output : 4
Explanation : (4, 1), (1, 4), (6, 1) and (1, 6) are the pairs
Simple approach: A simple approach is to check for all possible pairs and count the number of ordered pairs whose bitwise & returns 0.
Below is the implementation of the above idea:
C++
#include <bits/stdc++.h>
using namespace std;
int countPairs( int a[], int n)
{
int count = 0;
for ( int i = 0; i < n; i++) {
for ( int j = i + 1; j < n; j++)
if ((a[i] & a[j]) == 0)
count += 2;
}
return count;
}
int main()
{
int a[] = { 3, 4, 2 };
int n = sizeof (a) / sizeof (a[0]);
cout << countPairs(a, n);
return 0;
}
|
Java
class GFG {
static int countPairs( int a[], int n)
{
int count = 0 ;
for ( int i = 0 ; i < n; i++) {
for ( int j = i + 1 ; j < n; j++)
if ((a[i] & a[j]) == 0 )
count += 2 ;
}
return count;
}
public static void main(String arg[])
{
int a[] = { 3 , 4 , 2 };
int n = a.length;
System.out.print(countPairs(a, n));
}
}
|
Python3
def countPairs(a, n):
count = 0
for i in range ( 0 , n):
for j in range (i + 1 , n):
if (a[i] & a[j]) = = 0 :
count + = 2
return count
a = [ 3 , 4 , 2 ]
n = len (a)
print (countPairs(a, n))
|
C#
using System;
class GFG {
static int countPairs( int []a, int n)
{
int count = 0;
for ( int i = 0; i < n; i++)
{
for ( int j = i + 1; j < n; j++)
if ((a[i] & a[j]) == 0)
count += 2;
}
return count;
}
public static void Main()
{
int []a = { 3, 4, 2 };
int n = a.Length;
Console.Write(countPairs(a, n));
}
}
|
PHP
<?php
function countPairs( $a , $n )
{
$count = 0;
for ( $i = 0; $i < $n ; $i ++)
{
for ( $j = $i + 1; $j < $n ; $j ++)
if (( $a [ $i ] & $a [ $j ]) == 0)
$count += 2;
}
return $count ;
}
{
$a = array (3, 4, 2);
$n = sizeof( $a ) / sizeof( $a [0]);
echo countPairs( $a , $n );
return 0;
}
|
JavaScript
<script>
const countPairs = (a, n) => {
let count = 0;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++)
if ((a[i] & a[j]) == 0)
count += 2;
}
return count;
}
let a = [3, 4, 2];
let n = a.length;
document.write(countPairs(a, n));
</script>
?>
|
Time Complexity: O(n2)
Auxiliary Space: O(1)
Efficient approach: An efficient approach is to use Sum over Subsets Dynamic Programming method and count the number of ordered pairs. In the SOS DP we find out the pairs whose bitwise & returned 0. Here we need to count the number of pairs.
Some key observations are the constraints, the maximum that an array element can be is 104. Calculating the mask up to (1<<15) will give us our answer. Use hashing to count the occurrence of every element. If the last bit is OFF, then relating to SOS dp, we will have a base case since there is only one possibility of OFF bit.
dp[mask][0] = freq(mask)
If the last bit is set ON, then we will have the base case as:
dp[mask][0] = freq(mask) + freq(mask^1)
We add freq(mask^1) to add the other possibility of OFF bit.
Iterate over N=15 bits, which is the maximum possible.
Let’s consider the i-th bit to be 0, then no subset can differ from the mask in the i-th bit as it would mean that the numbers will have a 1 at i-th bit where the mask has a 0 which would mean that it is not a subset of the mask. Thus we conclude that the numbers now differ in the first (i-1) bits only. Hence,
DP(mask, i) = DP(mask, i-1)
Now the second case, if the i-th bit is 1, it can be divided into two non-intersecting sets. One containing numbers with i-th bit as 1 and differing from mask in the next (i-1) bits. Second containing numbers with ith bit as 0 and differing from mask
(2i) in next (i-1) bits. Hence,
DP(mask, i) = DP(mask, i-1) + DP(mask
2i, i-1).
DP[mask][i] stores the number of subsets of mask which differ from mask only in first i bits. Iterate for all array elements, and for every array element add the number of subsets (dp[ ( ( 1<<N ) – 1 ) ^ a[i] ][ N ]) to the number of pairs. N = maximum number of bits.
Explanation of addition of dp[ ( ( 1<<N ) – 1 ) ^ a[i] ][N] to the number of pairs: Take an example of A[i] being 5, which is 101 in binary. For better understanding, assume N=3 in this case, therefore, the reverse of 101 will be 010 which on applying bitwise & gives 0. So (1<<3) gives 1000 which on subtraction from 1 gives 111. 111
101 gives 010 which is the reversed bit.So dp[((1<<N)-1)^a[i]][N] will have the number of subsets that returns 0 on applying bitwise & operator.
Below is the implementation of the above idea:
C++
#include <bits/stdc++.h>
using namespace std;
const int N = 15;
long long countPairs( int a[], int n)
{
unordered_map< int , int > hash;
long long dp[1 << N][N + 1];
memset (dp, 0, sizeof (dp));
for ( int i = 0; i < n; ++i)
hash[a[i]] += 1;
for ( long long mask = 0; mask < (1 << N); ++mask) {
if (mask & 1)
dp[mask][0] = hash[mask] + hash[mask ^ 1];
else
dp[mask][0] = hash[mask];
for ( int i = 1; i <= N; ++i) {
if (mask & (1 << i))
{
dp[mask][i] = dp[mask][i - 1] +
dp[mask ^ (1 << i)][i - 1];
}
else
dp[mask][i] = dp[mask][i - 1];
}
}
long long ans = 0;
for ( int i = 0; i < n; i++)
ans += dp[((1 << N) - 1) ^ a[i]][N];
return ans;
}
int main()
{
int a[] = { 5, 4, 1, 6 };
int n = sizeof (a) / sizeof (a[0]);
cout << countPairs(a, n);
return 0;
}
|
Java
import java.util.*;
class GFG{
static int N = 15 ;
public static int countPairs( int a[],
int n)
{
HashMap<Integer,
Integer> hash = new HashMap<>();
int dp[][] = new int [ 1 << N][N + 1 ];
for ( int i = 0 ; i < n; ++i)
{
if (hash.containsKey(a[i]))
{
hash.replace(a[i],
hash.get(a[i]) + 1 );
}
else
{
hash.put(a[i], 1 );
}
}
for ( int mask = 0 ;
mask < ( 1 << N); ++mask)
{
if ((mask & 1 ) != 0 )
{
if (hash.containsKey(mask))
{
dp[mask][ 0 ] = hash.get(mask);
}
if (hash.containsKey(mask ^ 1 ))
{
dp[mask][ 0 ] += hash.get(mask ^ 1 );
}
}
else
{
if (hash.containsKey(mask))
{
dp[mask][ 0 ] = hash.get(mask);
}
}
for ( int i = 1 ; i <= N; ++i)
{
if ((mask & ( 1 << i)) != 0 )
{
dp[mask][i] = dp[mask][i - 1 ] +
dp[mask ^ ( 1 << i)][i - 1 ];
}
else
{
dp[mask][i] = dp[mask][i - 1 ];
}
}
}
int ans = 0 ;
for ( int i = 0 ; i < n; i++)
{
ans += dp[(( 1 << N) - 1 ) ^ a[i]][N];
}
return ans;
}
public static void main(String[] args)
{
int a[] = { 5 , 4 , 1 , 6 };
int n = a.length;
System.out.print(countPairs(a, n));
}
}
|
Python3
N = 15
def countPairs(a, n):
Hash = {}
dp = [[ 0 for i in range (N + 1 )] for j in range ( 1 << N)]
for i in range (n):
if a[i] not in Hash :
Hash [a[i]] = 1
else :
Hash [a[i]] + = 1
mask = 0
while (mask < ( 1 << N)):
if mask not in Hash :
Hash [mask] = 0
if (mask & 1 ):
dp[mask][ 0 ] = Hash [mask] + Hash [mask ^ 1 ]
else :
dp[mask][ 0 ] = Hash [mask]
for i in range ( 1 , N + 1 ):
if (mask & ( 1 << i)):
dp[mask][i] = dp[mask][i - 1 ] + dp[mask ^ ( 1 << i)][i - 1 ]
else :
dp[mask][i] = dp[mask][i - 1 ]
mask + = 1
ans = 0
for i in range (n):
ans + = dp[(( 1 << N) - 1 ) ^ a[i]][N]
return ans
a = [ 5 , 4 , 1 , 6 ]
n = len (a)
print (countPairs(a, n))
|
C#
using System;
using System.Collections.Generic;
class GFG {
static int N = 15;
static int countPairs( int [] a, int n)
{
Dictionary< int , int > hash = new Dictionary< int , int >();
int [, ] dp = new int [1 << N, N + 1];
for ( int i = 0; i < n; ++i)
{
if (hash.ContainsKey(a[i]))
{
hash[a[i]] += 1;
}
else
{
hash.Add(a[i], 1);
}
}
for ( int mask = 0;
mask < (1 << N); ++mask)
{
if ((mask & 1) != 0)
{
if (hash.ContainsKey(mask))
{
dp[mask, 0] = hash[mask];
}
if (hash.ContainsKey(mask ^ 1))
{
dp[mask, 0] += hash[mask ^ 1];
}
}
else
{
if (hash.ContainsKey(mask))
{
dp[mask, 0] = hash[mask];
}
}
for ( int i = 1; i <= N; ++i)
{
if ((mask & (1 << i)) != 0)
{
dp[mask, i] = dp[mask, i - 1] +
dp[mask ^ (1 << i), i - 1];
}
else
{
dp[mask, i] = dp[mask, i - 1];
}
}
}
int ans = 0;
for ( int i = 0; i < n; i++)
{
ans += dp[((1 << N) - 1) ^ a[i], N];
}
return ans;
}
static void Main()
{
int [] a = {5, 4, 1, 6};
int n = a.Length;
Console.WriteLine(countPairs(a, n));
}
}
|
Javascript
<script>
const N = 15;
function countPairs(a, n)
{
let hash = new Map();
let dp = new Array((1 << N));
for (let i = 0; i < (1 << N); i++) {
dp[i] = new Array(N+1).fill(0);
}
for (let i = 0; i < n; ++i){
if (hash.has(a[i])){
hash.set(a[i], hash.get(a[i]) + 1);
}
else {
hash.set(a[i], 1);
}
}
for (let mask = 0; mask < (1 << N); mask++) {
if (mask & 1){
dp[mask][0] = ((hash.get(mask) != undefined) ? hash.get(mask): 0) + ((hash.get((mask ^ 1)) != undefined) ? hash.get((mask^1)): 0);
}
else {
dp[mask][0] = hash.get(mask) != undefined ? hash.get(mask) : 0;
}
for (let i = 1; i <= N; i++) {
if (mask & (1 << i)){
dp[mask][i] = dp[mask][i - 1] + dp[mask ^ (1 << i)][i - 1];
}
else {
dp[mask][i] = dp[mask][i - 1];
}
}
}
let ans = 0;
for (let i = 0; i < n; i++){
ans = ans + dp[((1 << N) - 1) ^ a[i]][N];
}
return ans;
}
let a = [ 5, 4, 1, 6 ];
let n = a.length
document.write(countPairs(a, n));
</script>
|
Time Complexity: O(N*2N) where N=15 which is a maximum number of bits possible, since Amax=104.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...