Count permutations whose prefix & suffix AND are same for each index – GeeksforGeeks

Given an array arr[] of size N, Return the number of permutations of array arr[] which satisfy the condition arr[1] & arr[2] & . . . & arr[i] = arr[i+1] & arr[i+2] & . . . & arr[N] , for all i.

Note: Here & denotes the bitwise AND operation.

Examples:

Input: N = 3, arr[] = { 1, 1, 1 } 
Output: 6 
Explanation: Since all the numbers are equal, whatever permutation we take, the sequence will follow the above condition. There are a total of 6 permutations possible with index numbers from 1 to 3 : [1,  2,  3],  [1,  3,  2],  [2, 1, 3],  [2, 3, 1],  [3, 1,  2],  [3, 2, 1].

Input: N = 4, arr[] = { 1, 3, 5, 1 }
Output: 4

Approach: This problem can be solved based on the following idea:

Consider an arbitrary sequence b1, b2, . . ., bn. First, let us define the arrays AND_pref and AND_suf of length N where 

• AND_prefi = b₁ & b₂ & . . . & b_i and 
• AND_sufi = b_i & b_i+1 & . . . & b_n.

According to the definition of the sequence: AND_pref1 = AND_suf2. Now AND_pref2 ≤ AND_pref1 = AND_suf2 ≤ AND_suf3. Also according to the definition, AND_pref2 = AND_suf3. This means that b1 = AND_pref2 = AND_suf3. 

Similarly, for all i from 1 to n, we get AND_prefi = b1 and AND_sufi = b1.
Therefore for the sequence, b₁ = b_n and the b_i must be a super mask of  b₁ for all i from 2 to n − 1.

Follow the steps below to solve the problem:

• Initialize a variable preAnd with ( 1 << 30 ) – 1.
• Run a loop from i = 0 to n-1 and update preAnd with ( preAnd & arr[i] ).   
• Initialize a count variable (say cnt) with 0.
• Run a loop from i = 0 to n – 1 
  • If preAnd = arr[i], then Increment cnt by 1.
  • Compute (cnt * ( cnt – 1 ) * (n – 2) !) % (1e9 + 7) and store it in the answer variable.
• Return the answer.

Below is the implementation of the above approach:

Time Complexity: O(N) 
Auxiliary Space: O(1)

Related Articles: