Given a matrix **A** of size **NxN**, we need to find the number of inversion pairs in it. Inversion count in a matrix is defined as the number of pairs satisfying the following conditions :

- x
_{1}≤ x_{2} - y
_{1}≤ y_{2} - A[x
_{2}][y_{2}] < A[x_{1}][y_{1}]

**Constraints :**

- 1 ≤ A
_{i,j}≤ 10^{9} - 1 ≤ N ≤ 10
^{3}

Examples:

For simplicity, let's take a 2x2 matrix : A = {{7, 5}, {3, 1}}; The inversion pairs are : (7, 5), (3, 1), (7, 3), (5, 1) and (7, 1) Output : 5

To solve this problem, we need to know the following things :

- Finding number of inversion pairs in a 1D array using Binary Indexed Tree (BIT)

https://www.geeksforgeeks.org/count-inversions-array-set-3-using-bit - 2D BIT

https://www.geeksforgeeks.org/two-dimensional-binary-indexed-tree-or-fenwick-tree

Since, we need to find number of inversion pairs in a matrix, first thing we need to do is to store the elements of the matrix in another array, say v and sort the array v so that we can compare the elements of the unsorted matrix with v and find the number of inversion pairs using BIT. But it is given that the values of the elements are very large (10^{9}), so we cannot use the values of the elements in the matrix as indices in the BIT. Thus, we need to use the position of the elements as indexes in the 2D BIT.

We are going to use the tuple (-A[i][j], i, j) for each element of the matrix and store it in an array, say ‘v’. Then we need to sort v according to the value of -A[i][j] in ascending order, so that the largest element of the matrix will be stored at index 0 and the smallest one at the last index of v. Now, the problem is reduced to finding inversion pairs in a 1D array, the only exception is that we are going to use a 2D BIT.

Note that here we are using negative values of A[i][j], simply because we are going to traverse v from left to right, i.e., from the largest number in the matrix to the smallest one(because that’s what we do when finding inversion pairs in a 1D array using BIT). One can also use positive values and traverse v from right to left fashion, final result will remain same.

**Algorithm :**

1. Initialize inv_pair_cnt = 0, which will store the number of inversion pairs. 2. Store the tuple (-A[i][j], i, j) in an array, say v, where A[i][j] is the element of the matrix A at position (i, j). 3. Sort the array v according to the first element of the tuple, i.e., according to the value of -A[i][j]. 4. Traverse the array v and do the following : - Initialize an array, say 'pairs' to store the position (i, j) of the tuples of v. - while the current tuple of v and all its adjacent tuples whose first value, i.e., -A[i][j] is same, do - Push the current tuple's position pair (i, j) into 'pairs'. - Add to inv_pair_cnt, the number of elements which are less than the current element(i.e., A[i][j]) and lie on the right side in the sorted array v, by calling the query operation of BIT and passing i and j as arguments. - For each position pair (i, j) stored in the array 'pairs', update the position (i, j) in the 2D BIT by 1. 5. Finally, inv_pair_cnt will contain the number of inversion pairs.

Here is the C++ implementation :

`// C++ program to count the number of inversion ` `// pairs in a 2D matrix ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// for simplicity, we are taking N as 4 ` `#define N 4 ` ` ` `// Function to update a 2D BIT. It updates the ` `// value of bit[l][r] by adding val to bit[l][r] ` `void` `update(` `int` `l, ` `int` `r, ` `int` `val, ` `int` `bit[][N + 1]) ` `{ ` ` ` `for` `(` `int` `i = l; i <= N; i += i & -i) ` ` ` `for` `(` `int` `j = r; j <= N; j += j & -j) ` ` ` `bit[i][j] += val; ` `} ` ` ` `// function to find cumulative sum upto ` `// index (l, r) in the 2D BIT ` `long` `long` `query(` `int` `l, ` `int` `r, ` `int` `bit[][N + 1]) ` `{ ` ` ` `long` `long` `ret = 0; ` ` ` `for` `(` `int` `i = l; i > 0; i -= i & -i) ` ` ` `for` `(` `int` `j = r; j > 0; j -= j & -j) ` ` ` `ret += bit[i][j]; ` ` ` ` ` `return` `ret; ` `} ` ` ` `// function to count and return the number ` `// of inversion pairs in the matrix ` `long` `long` `countInversionPairs(` `int` `mat[][N]) ` `{ ` ` ` `// the 2D bit array and initialize it with 0. ` ` ` `int` `bit[N+1][N+1] = {0}; ` ` ` ` ` `// v will store the tuple (-mat[i][j], i, j) ` ` ` `vector<pair<` `int` `, pair<` `int` `, ` `int` `> > > v; ` ` ` ` ` `// store the tuples in the vector v ` ` ` `for` `(` `int` `i = 0; i < N; ++i) ` ` ` `for` `(` `int` `j = 0; j < N; ++j) ` ` ` ` ` `// Note that we are not using the pair ` ` ` `// (0, 0) because BIT update and query ` ` ` `// operations are not done on index 0 ` ` ` `v.push_back(make_pair(-mat[i][j], ` ` ` `make_pair(i+1, j+1))); ` ` ` ` ` `// sort the vector v according to the ` ` ` `// first element of the tuple, i.e., -mat[i][j] ` ` ` `sort(v.begin(), v.end()); ` ` ` ` ` `// inv_pair_cnt will store the number of ` ` ` `// inversion pairs ` ` ` `long` `long` `inv_pair_cnt = 0; ` ` ` ` ` `// traverse all the tuples of vector v ` ` ` `int` `i = 0; ` ` ` `while` `(i < v.size()) ` ` ` `{ ` ` ` `int` `curr = i; ` ` ` ` ` `// 'pairs' will store the position of each element, ` ` ` `// i.e., the pair (i, j) of each tuple of the vector v ` ` ` `vector<pair<` `int` `, ` `int` `> > pairs; ` ` ` ` ` `// consider the current tuple in v and all its ` ` ` `// adjacent tuples whose first value, i.e., the ` ` ` `// value of –mat[i][j] is same ` ` ` `while` `(curr < v.size() && ` ` ` `(v[curr].first == v[i].first)) ` ` ` `{ ` ` ` `// push the position of the current element in 'pairs' ` ` ` `pairs.push_back(make_pair(v[curr].second.first, ` ` ` `v[curr].second.second)); ` ` ` ` ` `// add the number of elements which are ` ` ` `// less than the current element and lie on the right ` ` ` `// side in the vector v ` ` ` `inv_pair_cnt += query(v[curr].second.first, ` ` ` `v[curr].second.second, bit); ` ` ` ` ` `curr++; ` ` ` `} ` ` ` ` ` `vector<pair<` `int` `, ` `int` `> >::iterator it; ` ` ` ` ` `// traverse the 'pairs' vector ` ` ` `for` `(it = pairs.begin(); it != pairs.end(); ++it) ` ` ` `{ ` ` ` `int` `x = it->first; ` ` ` `int` `y = it->second; ` ` ` ` ` `// update the positon (x, y) by 1 ` ` ` `update(x, y, 1, bit); ` ` ` `} ` ` ` ` ` `i = curr; ` ` ` `} ` ` ` ` ` `return` `inv_pair_cnt; ` `} ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `int` `mat[N][N] = { { 4, 7, 2, 9 }, ` ` ` `{ 6, 4, 1, 7 }, ` ` ` `{ 5, 3, 8, 1 }, ` ` ` `{ 3, 2, 5, 6 } }; ` ` ` ` ` `long` `long` `inv_pair_cnt = countInversionPairs(mat); ` ` ` ` ` `cout << ` `"The number of inversion pairs are : "` ` ` `<< inv_pair_cnt << endl; ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

Output:

The number of inversion pairs are : 43

**Time Complexity** : O(log(NxN)), where N is the size of the matrix

**Space Complexity** : O(NxN)

This article is contributed by **Avinash Kumar Saw**. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

## Recommended Posts:

- Count frequency of k in a matrix of size n where matrix(i, j) = i+j
- Maximum sub-matrix area having count of 1's one more than count of 0's
- Count pairs from two sorted matrices with given sum
- Count pairs (A, B) such that A has X and B has Y number of set bits and A+B = C
- Count the number of pairs that have column sum greater than row sum
- Count majority element in a matrix
- Count all sorted rows in a matrix
- Count all 0s which are blocked by 1s in binary matrix
- Count all the columns in a matrix which are sorted in descending
- Count entries equal to x in a special matrix
- Count rows in a matrix that consist of same element
- Count of elements of an array present in every row of NxM matrix
- Count all possible paths from top left to bottom right of a mXn matrix
- Count the number of ways to traverse a Matrix
- Count elements smaller than or equal to x in a sorted matrix