### LeetCode Challenge #2352. Equal Row and Column Pairs

Given a 0-indexed `n x n` integer matrix `grid`return the number of pairs `(ri, cj)` such that row `ri` and column `cj` are equal.

A row and column pair is considered equal if they contain the same elements in the same order (i.e., an equal array).

Example 1:

```Input: grid = [[3,2,1],[1,7,6],[2,7,7]]
Output: 1
Explanation: There is 1 equal row and column pair:
- (Row 2, Column 1): [2,7,7]
```

Example 2:

```Input: grid = [[3,1,2,2],[1,4,4,5],[2,4,2,2],[2,4,2,2]]
Output: 3
Explanation: There are 3 equal row and column pairs:
- (Row 0, Column 0): [3,1,2,2]
- (Row 2, Column 2): [2,4,2,2]
- (Row 3, Column 2): [2,4,2,2]
```

Constraints:

• `n == grid.length == grid[i].length`
• `1 <= n <= 200`
• `1 <= grid[i][j] <= 105`
##### Video Solution
###### C++ Solution
```				```
class Solution {
public:
int equalPairs(vector<vector<int>>& grid) {

map<vector<int>,int> freq;
int n=grid.size();
int count=0;

for(auto i: grid)
{
freq[i]++;
}

for(int j=0; j<n; j++)
{
vector<int> helper;
for(int i=0; i<n; i++)
{
helper.push_back(grid[i][j]);
}

count+=freq[helper];
}

return count;
}
};
```
```
###### Code Explanation

In this program, the function takes a 2D vector ‘grid’ as input, where each row represents a pair of elements, and it aims to count the number of pairs in the grid that are equal. When one column and one row are equal, it is considered a 1 element.

1. We will make a hash map ‘freq’ in which we will store the count of rows. This map will be used to store the frequency of each unique pair in the grid.
2. The for loop iterates through each row of the ‘grid’ and increments the frequency of each unique pair in the ‘freq’ map.
3. Now we will iterate column-wise ‘grid’ to check equal pairs. For each column, we have used a vector ‘helper’ in which elements of ‘i’ and ‘j’ are pushed.
4. Outside of the loop, we will increment the count by the frequency of the corresponding pair in the ‘freq’ map.
count += freq[ helper ] ;
1. The total count of equal pairs is returned.