# Number of ordered pairs such that (Ai & Aj) = 0

Given an array A[] of n integers, find out the number of ordered pairs such that A_{i}&A_{j} is zero, where 0<=(i,j)<n. Consider (i, j) and (j, i) to be different.

**Constraints: **

1<=n<=10^{4}

1<=A_{i}<=10^{4}

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 above idea:

## C++

`// CPP program to calculate the number ` `// of ordered pairs such that their bitwise ` `// and is zero ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Naive function to count the number ` `// of ordered pairs such that their ` `// bitwise and is 0 ` `int` `countPairs(` `int` `a[], ` `int` `n) ` `{ ` ` ` `int` `count = 0; ` ` ` ` ` `// check for all possible pairs ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` `for` `(` `int` `j = i + 1; j < n; j++) ` ` ` `if` `((a[i] & a[j]) == 0) ` ` ` ` ` `// add 2 as (i, j) and (j, i) are ` ` ` `// considered different ` ` ` `count += 2; ` ` ` `} ` ` ` ` ` `return` `count; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `int` `a[] = { 3, 4, 2 }; ` ` ` `int` `n = ` `sizeof` `(a) / ` `sizeof` `(a[0]); ` ` ` `cout << countPairs(a, n); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program to calculate the number ` `// of ordered pairs such that their bitwise ` `// and is zero ` ` ` `class` `GFG { ` ` ` ` ` `// Naive function to count the number ` ` ` `// of ordered pairs such that their ` ` ` `// bitwise and is 0 ` ` ` `static` `int` `countPairs(` `int` `a[], ` `int` `n) ` ` ` `{ ` ` ` `int` `count = ` `0` `; ` ` ` ` ` `// check for all possible pairs ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) { ` ` ` `for` `(` `int` `j = i + ` `1` `; j < n; j++) ` ` ` `if` `((a[i] & a[j]) == ` `0` `) ` ` ` ` ` `// add 2 as (i, j) and (j, i) are ` ` ` `// considered different ` ` ` `count += ` `2` `; ` ` ` `} ` ` ` ` ` `return` `count; ` ` ` `} ` ` ` ` ` `// Driver Code ` ` ` `public` `static` `void` `main(String arg[]) ` ` ` `{ ` ` ` `int` `a[] = { ` `3` `, ` `4` `, ` `2` `}; ` ` ` `int` `n = a.length; ` ` ` `System.out.print(countPairs(a, n)); ` ` ` `} ` `} ` ` ` `// This code is contributed by Anant Agarwal. ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to calculate the number ` `# of ordered pairs such that their ` `# bitwise and is zero ` ` ` `# Naive function to count the number ` `# of ordered pairs such that their ` `# bitwise and is 0 ` `def` `countPairs(a, n): ` ` ` `count ` `=` `0` ` ` ` ` `# check for all possible pairs ` ` ` `for` `i ` `in` `range` `(` `0` `, n): ` ` ` `for` `j ` `in` `range` `(i ` `+` `1` `, n): ` ` ` `if` `(a[i] & a[j]) ` `=` `=` `0` `: ` ` ` ` ` `# add 2 as (i, j) and (j, i) are ` ` ` `# considered different ` ` ` `count ` `+` `=` `2` ` ` `return` `count ` ` ` `# Driver Code ` `a ` `=` `[ ` `3` `, ` `4` `, ` `2` `] ` `n ` `=` `len` `(a) ` `print` `(countPairs(a, n)) ` ` ` `# This code is contributed ` `# by Shreyanshi Arun. ` |

*chevron_right*

*filter_none*

## C#

`// C# program to calculate the number ` `// of ordered pairs such that their ` `// bitwise and is zero ` `using` `System; ` ` ` `class` `GFG { ` ` ` ` ` `// Naive function to count the number ` ` ` `// of ordered pairs such that their ` ` ` `// bitwise and is 0 ` ` ` `static` `int` `countPairs(` `int` `[]a, ` `int` `n) ` ` ` `{ ` ` ` `int` `count = 0; ` ` ` ` ` `// check for all possible pairs ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `{ ` ` ` `for` `(` `int` `j = i + 1; j < n; j++) ` ` ` `if` `((a[i] & a[j]) == 0) ` ` ` ` ` `// add 2 as (i, j) and (j, i) ` ` ` `// arev considered different ` ` ` `count += 2; ` ` ` `} ` ` ` ` ` `return` `count; ` ` ` `} ` ` ` ` ` `// Driver Code ` ` ` `public` `static` `void` `Main() ` ` ` `{ ` ` ` `int` `[]a = { 3, 4, 2 }; ` ` ` `int` `n = a.Length; ` ` ` `Console.Write(countPairs(a, n)); ` ` ` `} ` `} ` ` ` `// This code is contributed by nitin mittal. ` |

*chevron_right*

*filter_none*

## PHP

`<?php ` `// PHP program to calculate the number ` `// of ordered pairs such that their ` `// bitwise and is zero ` ` ` `// Naive function to count the number ` `// of ordered pairs such that their ` `// bitwise and is 0 ` `function` `countPairs(` `$a` `, ` `$n` `) ` `{ ` ` ` `$count` `= 0; ` ` ` ` ` `// check for all possible pairs ` ` ` `for` `(` `$i` `= 0; ` `$i` `< ` `$n` `; ` `$i` `++) ` ` ` `{ ` ` ` `for` `(` `$j` `= ` `$i` `+ 1; ` `$j` `< ` `$n` `; ` `$j` `++) ` ` ` `if` `((` `$a` `[` `$i` `] & ` `$a` `[` `$j` `]) == 0) ` ` ` ` ` `// add 2 as (i, j) and (j, i) are ` ` ` `// considered different ` ` ` `$count` `+= 2; ` ` ` `} ` ` ` ` ` `return` `$count` `; ` `} ` ` ` `// Driver Code ` `{ ` ` ` `$a` `= ` `array` `(3, 4, 2); ` ` ` `$n` `= sizeof(` `$a` `) / sizeof(` `$a` `[0]); ` ` ` `echo` `countPairs(` `$a` `, ` `$n` `); ` ` ` `return` `0; ` `} ` ` ` `// This code is contributed by nitin mittal ` `?> ` |

*chevron_right*

*filter_none*

**Output:**

4

**Time Complexity:** O(n^{2})

**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 10^{4}. 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(2^{i}) in next (i-1) bits. Hence,

DP(mask, i) = DP(mask, i-1) + DP(mask2^{i}, 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. 111101 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:

`// CPP program to calculate the number ` `// of ordered pairs such that their bitwise ` `// and is zero ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `const` `int` `N = 15; ` ` ` `// efficient function to count pairs ` `long` `long` `countPairs(` `int` `a[], ` `int` `n) ` `{ ` ` ` `// stores the frequency of each number ` ` ` `unordered_map<` `int` `, ` `int` `> hash; ` ` ` ` ` `long` `long` `dp[1 << N][N + 1]; ` ` ` ` ` `memset` `(dp, 0, ` `sizeof` `(dp)); ` `// initialize 0 to all ` ` ` ` ` `// count the frequency of every element ` ` ` `for` `(` `int` `i = 0; i < n; ++i) ` ` ` `hash[a[i]] += 1; ` ` ` ` ` `// iterate for al possible values that a[i] can be ` ` ` `for` `(` `long` `long` `mask = 0; mask < (1 << N); ++mask) { ` ` ` ` ` `// if the last bit is ON ` ` ` `if` `(mask & 1) ` ` ` `dp[mask][0] = hash[mask] + hash[mask ^ 1]; ` ` ` `else` `// is the last bit is OFF ` ` ` `dp[mask][0] = hash[mask]; ` ` ` ` ` `// iterate till n ` ` ` `for` `(` `int` `i = 1; i <= N; ++i) { ` ` ` ` ` `// if mask's ith bit is set ` ` ` `if` `(mask & (1 << i)) ` ` ` `{ ` ` ` `dp[mask][i] = dp[mask][i - 1] + ` ` ` `dp[mask ^ (1 << i)][i - 1]; ` ` ` `} ` ` ` `else` `// if mask's ith bit is not set ` ` ` `dp[mask][i] = dp[mask][i - 1]; ` ` ` `} ` ` ` `} ` ` ` ` ` `long` `long` `ans = 0; ` ` ` ` ` `// iterate for all the array element ` ` ` `// and count the number of pairs ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `ans += dp[((1 << N) - 1) ^ a[i]][N]; ` ` ` ` ` `// return answer ` ` ` `return` `ans; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `int` `a[] = { 5, 4, 1, 6 }; ` ` ` `int` `n = ` `sizeof` `(a) / ` `sizeof` `(a[0]); ` ` ` `cout << countPairs(a, n); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

Output:

4

**Time Complexity:** O(N*2^{N}) where N=15 which is maximum number of bits possible, since A_{max}=10^{4}.

## Recommended Posts:

- Count pairs (A, B) such that A has X and B has Y number of set bits and A+B = C
- Count no. of ordered subsets having a particular XOR value
- Find the number of distinct pairs of vertices which have a distance of exactly k in a tree
- Number of Co-prime pairs obtained from the sum of digits of elements in the given range
- Total distinct pairs from two arrays such that second number can be obtained by inverting bits of first
- Largest divisible pairs subset
- Maximum Length Chain of Pairs | DP-20
- Maximum sum of pairs with specific difference
- Print Maximum Length Chain of Pairs
- Counting pairs when a person can form pair with at most one
- Count pairs of non-overlapping palindromic sub-strings of the given string
- Ways to fill N positions using M colors such that there are exactly K pairs of adjacent different colors
- Number of ways to represent a number as sum of k fibonacci numbers
- Super Ugly Number (Number whose prime factors are in given set)
- Find the maximum number of composite summands of a number

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.