Skip to content

Commit 85ac0df

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1380
No.1380.Lucky Numbers in a Matrix
1 parent 14a434d commit 85ac0df

File tree

6 files changed

+238
-53
lines changed

6 files changed

+238
-53
lines changed

‎solution/1300-1399/1380.Lucky Numbers in a Matrix/README.md

+82-17
Original file line numberDiff line numberDiff line change
@@ -63,10 +63,10 @@
6363

6464
```python
6565
class Solution:
66-
def luckyNumbers (self, matrix: List[List[int]]) -> List[int]:
67-
row_min = {min(rows) for rows in matrix}
68-
col_max = {max(cols) for cols in zip(*matrix)}
69-
return [e for e in row_min if e in col_max]
66+
def luckyNumbers(self, matrix: List[List[int]]) -> List[int]:
67+
rows = {min(row) for row in matrix}
68+
cols = {max(col) for col in zip(*matrix)}
69+
return list(rows & cols)
7070
```
7171

7272
### **Java**
@@ -77,28 +77,93 @@ class Solution:
7777
class Solution {
7878
public List<Integer> luckyNumbers (int[][] matrix) {
7979
int m = matrix.length, n = matrix[0].length;
80-
Set<Integer> rowMin = new HashSet<>();
81-
List<Integer> res = new ArrayList<>();
80+
int[] rows = new int[m];
81+
int[] cols = new int[n];
82+
Arrays.fill(rows, Integer.MAX_VALUE);
8283
for (int i = 0; i < m; ++i) {
83-
int min = Integer.MAX_VALUE;
8484
for (int j = 0; j < n; ++j) {
85-
min = Math.min(min, matrix[i][j]);
85+
rows[i] = Math.min(rows[i], matrix[i][j]);
86+
cols[j] = Math.max(cols[j], matrix[i][j]);
8687
}
87-
rowMin.add(min);
8888
}
89-
90-
for (int j = 0; j < n; ++j) {
91-
int max = Integer.MIN_VALUE;
92-
for (int i = 0; i < m; ++i) {
93-
max = Math.max(max, matrix[i][j]);
89+
List<Integer> ans = new ArrayList<>();
90+
for (int i = 0; i < m; ++i) {
91+
for (int j = 0; j < n; ++j) {
92+
if (rows[i] == cols[j]) {
93+
ans.add(matrix[i][j]);
94+
}
9495
}
95-
if (rowMin.contains(max)) {
96-
res.add(max);
96+
}
97+
return ans;
98+
}
99+
}
100+
```
101+
102+
### **C++**
103+
104+
```cpp
105+
class Solution {
106+
public:
107+
vector<int> luckyNumbers (vector<vector<int>>& matrix) {
108+
int m = matrix.size(), n = matrix[0].size();
109+
vector<int> rows(m, INT_MAX);
110+
vector<int> cols(n);
111+
for (int i = 0; i < m; ++i)
112+
{
113+
for (int j = 0; j < n; ++j)
114+
{
115+
rows[i] = min(rows[i], matrix[i][j]);
116+
cols[j] = max(cols[j], matrix[i][j]);
97117
}
118+
}
119+
vector<int> ans;
120+
for (int i = 0; i < m; ++i)
121+
for (int j = 0; j < n; ++j)
122+
if (rows[i] == cols[j])
123+
ans.push_back(matrix[i][j]);
124+
return ans;
125+
}
126+
};
127+
```
128+
129+
### **Go**
98130
131+
```go
132+
func luckyNumbers (matrix [][]int) []int {
133+
m, n := len(matrix), len(matrix[0])
134+
rows, cols := make([]int, m), make([]int, n)
135+
for i := range rows {
136+
rows[i] = math.MaxInt32
137+
}
138+
for i, row := range matrix {
139+
for j, v := range row {
140+
rows[i] = min(rows[i], v)
141+
cols[j] = max(cols[j], v)
142+
}
143+
}
144+
var ans []int
145+
for i, row := range matrix {
146+
for j, v := range row {
147+
if rows[i] == cols[j] {
148+
ans = append(ans, v)
149+
}
99150
}
100-
return res;
101151
}
152+
return ans
153+
}
154+
155+
func min(a, b int) int {
156+
if a < b {
157+
return a
158+
}
159+
return b
160+
}
161+
162+
func max(a, b int) int {
163+
if a > b {
164+
return a
165+
}
166+
return b
102167
}
103168
```
104169

‎solution/1300-1399/1380.Lucky Numbers in a Matrix/README_EN.md

+82-17
Original file line numberDiff line numberDiff line change
@@ -51,10 +51,10 @@
5151

5252
```python
5353
class Solution:
54-
def luckyNumbers (self, matrix: List[List[int]]) -> List[int]:
55-
row_min = {min(rows) for rows in matrix}
56-
col_max = {max(cols) for cols in zip(*matrix)}
57-
return [e for e in row_min if e in col_max]
54+
def luckyNumbers(self, matrix: List[List[int]]) -> List[int]:
55+
rows = {min(row) for row in matrix}
56+
cols = {max(col) for col in zip(*matrix)}
57+
return list(rows & cols)
5858
```
5959

6060
### **Java**
@@ -63,28 +63,93 @@ class Solution:
6363
class Solution {
6464
public List<Integer> luckyNumbers (int[][] matrix) {
6565
int m = matrix.length, n = matrix[0].length;
66-
Set<Integer> rowMin = new HashSet<>();
67-
List<Integer> res = new ArrayList<>();
66+
int[] rows = new int[m];
67+
int[] cols = new int[n];
68+
Arrays.fill(rows, Integer.MAX_VALUE);
6869
for (int i = 0; i < m; ++i) {
69-
int min = Integer.MAX_VALUE;
7070
for (int j = 0; j < n; ++j) {
71-
min = Math.min(min, matrix[i][j]);
71+
rows[i] = Math.min(rows[i], matrix[i][j]);
72+
cols[j] = Math.max(cols[j], matrix[i][j]);
7273
}
73-
rowMin.add(min);
7474
}
75-
76-
for (int j = 0; j < n; ++j) {
77-
int max = Integer.MIN_VALUE;
78-
for (int i = 0; i < m; ++i) {
79-
max = Math.max(max, matrix[i][j]);
75+
List<Integer> ans = new ArrayList<>();
76+
for (int i = 0; i < m; ++i) {
77+
for (int j = 0; j < n; ++j) {
78+
if (rows[i] == cols[j]) {
79+
ans.add(matrix[i][j]);
80+
}
8081
}
81-
if (rowMin.contains(max)) {
82-
res.add(max);
82+
}
83+
return ans;
84+
}
85+
}
86+
```
87+
88+
### **C++**
89+
90+
```cpp
91+
class Solution {
92+
public:
93+
vector<int> luckyNumbers (vector<vector<int>>& matrix) {
94+
int m = matrix.size(), n = matrix[0].size();
95+
vector<int> rows(m, INT_MAX);
96+
vector<int> cols(n);
97+
for (int i = 0; i < m; ++i)
98+
{
99+
for (int j = 0; j < n; ++j)
100+
{
101+
rows[i] = min(rows[i], matrix[i][j]);
102+
cols[j] = max(cols[j], matrix[i][j]);
83103
}
104+
}
105+
vector<int> ans;
106+
for (int i = 0; i < m; ++i)
107+
for (int j = 0; j < n; ++j)
108+
if (rows[i] == cols[j])
109+
ans.push_back(matrix[i][j]);
110+
return ans;
111+
}
112+
};
113+
```
114+
115+
### **Go**
84116
117+
```go
118+
func luckyNumbers (matrix [][]int) []int {
119+
m, n := len(matrix), len(matrix[0])
120+
rows, cols := make([]int, m), make([]int, n)
121+
for i := range rows {
122+
rows[i] = math.MaxInt32
123+
}
124+
for i, row := range matrix {
125+
for j, v := range row {
126+
rows[i] = min(rows[i], v)
127+
cols[j] = max(cols[j], v)
128+
}
129+
}
130+
var ans []int
131+
for i, row := range matrix {
132+
for j, v := range row {
133+
if rows[i] == cols[j] {
134+
ans = append(ans, v)
135+
}
85136
}
86-
return res;
87137
}
138+
return ans
139+
}
140+
141+
func min(a, b int) int {
142+
if a < b {
143+
return a
144+
}
145+
return b
146+
}
147+
148+
func max(a, b int) int {
149+
if a > b {
150+
return a
151+
}
152+
return b
88153
}
89154
```
90155

‎solution/1300-1399/1380.Lucky Numbers in a Matrix/Solution.cpp

+22
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
class Solution {
2+
public:
3+
vector<int> luckyNumbers (vector<vector<int>>& matrix) {
4+
int m = matrix.size(), n = matrix[0].size();
5+
vector<int> rows(m, INT_MAX);
6+
vector<int> cols(n);
7+
for (int i = 0; i < m; ++i)
8+
{
9+
for (int j = 0; j < n; ++j)
10+
{
11+
rows[i] = min(rows[i], matrix[i][j]);
12+
cols[j] = max(cols[j], matrix[i][j]);
13+
}
14+
}
15+
vector<int> ans;
16+
for (int i = 0; i < m; ++i)
17+
for (int j = 0; j < n; ++j)
18+
if (rows[i] == cols[j])
19+
ans.push_back(matrix[i][j]);
20+
return ans;
21+
}
22+
};

‎solution/1300-1399/1380.Lucky Numbers in a Matrix/Solution.go

+36
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
func luckyNumbers (matrix [][]int) []int {
2+
m, n := len(matrix), len(matrix[0])
3+
rows, cols := make([]int, m), make([]int, n)
4+
for i := range rows {
5+
rows[i] = math.MaxInt32
6+
}
7+
for i, row := range matrix {
8+
for j, v := range row {
9+
rows[i] = min(rows[i], v)
10+
cols[j] = max(cols[j], v)
11+
}
12+
}
13+
var ans []int
14+
for i, row := range matrix {
15+
for j, v := range row {
16+
if rows[i] == cols[j] {
17+
ans = append(ans, v)
18+
}
19+
}
20+
}
21+
return ans
22+
}
23+
24+
func min(a, b int) int {
25+
if a < b {
26+
return a
27+
}
28+
return b
29+
}
30+
31+
func max(a, b int) int {
32+
if a > b {
33+
return a
34+
}
35+
return b
36+
}

‎solution/1300-1399/1380.Lucky Numbers in a Matrix/Solution.java

+12-15
Original file line numberDiff line numberDiff line change
@@ -1,26 +1,23 @@
11
class Solution {
22
public List<Integer> luckyNumbers (int[][] matrix) {
33
int m = matrix.length, n = matrix[0].length;
4-
Set<Integer> rowMin = new HashSet<>();
5-
List<Integer> res = new ArrayList<>();
4+
int[] rows = new int[m];
5+
int[] cols = new int[n];
6+
Arrays.fill(rows, Integer.MAX_VALUE);
67
for (int i = 0; i < m; ++i) {
7-
int min = Integer.MAX_VALUE;
88
for (int j = 0; j < n; ++j) {
9-
min = Math.min(min, matrix[i][j]);
9+
rows[i] = Math.min(rows[i], matrix[i][j]);
10+
cols[j] = Math.max(cols[j], matrix[i][j]);
1011
}
11-
rowMin.add(min);
1212
}
13-
14-
for (int j = 0; j < n; ++j) {
15-
int max = Integer.MIN_VALUE;
16-
for (int i = 0; i < m; ++i) {
17-
max = Math.max(max, matrix[i][j]);
18-
}
19-
if (rowMin.contains(max)) {
20-
res.add(max);
13+
List<Integer> ans = new ArrayList<>();
14+
for (int i = 0; i < m; ++i) {
15+
for (int j = 0; j < n; ++j) {
16+
if (rows[i] == cols[j]) {
17+
ans.add(matrix[i][j]);
18+
}
2119
}
22-
2320
}
24-
return res;
21+
return ans;
2522
}
2623
}

‎solution/1300-1399/1380.Lucky Numbers in a Matrix/Solution.py

+4-4
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
class Solution:
2-
def luckyNumbers (self, matrix: List[List[int]]) -> List[int]:
3-
row_min = {min(rows) for rows in matrix}
4-
col_max = {max(cols) for cols in zip(*matrix)}
5-
return [e for e in row_min if e in col_max]
2+
def luckyNumbers(self, matrix: List[List[int]]) -> List[int]:
3+
rows = {min(row) for row in matrix}
4+
cols = {max(col) for col in zip(*matrix)}
5+
return list(rows & cols)

0 commit comments

Comments
 (0)