Description#
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:
![](https://spcdn.pages.dev/leetcode/problems/2352.Equal%20Row%20and%20Column%20Pairs/images/ex1.jpg)
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:
![](https://spcdn.pages.dev/leetcode/problems/2352.Equal%20Row%20and%20Column%20Pairs/images/ex2.jpg)
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
Solutions#
Solution 1#
1
2
3
4
| class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
g = [list(col) for col in zip(*grid)]
return sum(row == col for row in grid for col in g)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| class Solution {
public int equalPairs(int[][] grid) {
int n = grid.length;
int[][] g = new int[n][n];
for (int j = 0; j < n; ++j) {
for (int i = 0; i < n; ++i) {
g[i][j] = grid[j][i];
}
}
int ans = 0;
for (var row : grid) {
for (var col : g) {
int ok = 1;
for (int i = 0; i < n; ++i) {
if (row[i] != col[i]) {
ok = 0;
break;
}
}
ans += ok;
}
}
return ans;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| class Solution {
public:
int equalPairs(vector<vector<int>>& grid) {
int n = grid.size();
vector<vector<int>> g(n, vector<int>(n));
for (int j = 0; j < n; ++j) {
for (int i = 0; i < n; ++i) {
g[i][j] = grid[j][i];
}
}
int ans = 0;
for (auto& row : grid) {
for (auto& col : g) {
ans += row == col;
}
}
return ans;
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| func equalPairs(grid [][]int) (ans int) {
n := len(grid)
g := make([][]int, n)
for i := range g {
g[i] = make([]int, n)
for j := 0; j < n; j++ {
g[i][j] = grid[j][i]
}
}
for _, row := range grid {
for _, col := range g {
ok := 1
for i, v := range row {
if v != col[i] {
ok = 0
break
}
}
ans += ok
}
}
return
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| function equalPairs(grid: number[][]): number {
const n = grid.length;
const g = Array.from({ length: n }, () => Array.from({ length: n }, () => 0));
for (let j = 0; j < n; ++j) {
for (let i = 0; i < n; ++i) {
g[i][j] = grid[j][i];
}
}
let ans = 0;
for (const row of grid) {
for (const col of g) {
ans += Number(row.toString() === col.toString());
}
}
return ans;
}
|
Solution 2#
1
2
3
4
5
6
7
8
| class Solution:
def equalPairs(self, grid: List[List[int]]) -> int:
n = len(grid)
ans = 0
for i in range(n):
for j in range(n):
ans += all(grid[i][k] == grid[k][j] for k in range(n))
return ans
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| class Solution {
public int equalPairs(int[][] grid) {
int n = grid.length;
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
int ok = 1;
for (int k = 0; k < n; ++k) {
if (grid[i][k] != grid[k][j]) {
ok = 0;
break;
}
}
ans += ok;
}
}
return ans;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| class Solution {
public:
int equalPairs(vector<vector<int>>& grid) {
int n = grid.size();
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
int ok = 1;
for (int k = 0; k < n; ++k) {
if (grid[i][k] != grid[k][j]) {
ok = 0;
break;
}
}
ans += ok;
}
}
return ans;
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| func equalPairs(grid [][]int) (ans int) {
for i := range grid {
for j := range grid {
ok := 1
for k := range grid {
if grid[i][k] != grid[k][j] {
ok = 0
break
}
}
ans += ok
}
}
return
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| function equalPairs(grid: number[][]): number {
const n = grid.length;
let ans = 0;
for (let i = 0; i < n; ++i) {
for (let j = 0; j < n; ++j) {
let ok = 1;
for (let k = 0; k < n; ++k) {
if (grid[i][k] !== grid[k][j]) {
ok = 0;
break;
}
}
ans += ok;
}
}
return ans;
}
|