Skip to content

Commit 977f167

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1074
No.1074.Number of Submatrices That Sum to Target
1 parent 087d890 commit 977f167

File tree

8 files changed

+446
-26
lines changed

8 files changed

+446
-26
lines changed

‎solution/1000-1099/1073.Adding Two Negabinary Numbers/README.md

+7-2
Original file line numberDiff line numberDiff line change
@@ -55,9 +55,14 @@
5555

5656
**方法一：进位转换**
5757

58-
如果两个数对应的位与进位 $c$ 相加的结果大于 $1$，那么先执行操作：将结果减去 $2$，并向高位进位 $-1$。如果相加的结果为 $-1$，那么执行操作：将结果加上 $2$，并向高位进位 $1$。此时我们将结果加入到答案数组中，然后继续处理下一位。
58+
我们遍历两个数组，从最低位开始，记两个数组当前位的数字为 $a$ 和 $b$，进位为 $c$，三个数相加的结果为 $x$。
5959

60-
最后，我们需要去除答案数组中末尾的 $0$，并将数组反转，即可得到最终的答案。
60+
- 如果 $x \gt 1$，那么执行操作：将 $x$ 减去 $2$，并向高位进位 $-1$。
61+
- 如果 $x \lt 0$，那么执行操作：将 $x$ 加上 $2$，并向高位进位 $1$。
62+
63+
然后，我们将 $x$ 加入到答案数组中，然后继续处理下一位。
64+
65+
遍历结束后，去除答案数组中末尾的 $0$，并将数组反转，即可得到最终的答案。
6166

6267
时间复杂度 $O(\max(n, m))$，其中 $n$ 和 $m$ 分别是两个数组的长度。忽略答案的空间消耗，空间复杂度 $O(1)$。
6368

‎solution/1000-1099/1074.Number of Submatrices That Sum to Target/README.md

+164-1
Original file line numberDiff line numberDiff line change
@@ -54,22 +54,185 @@
5454

5555
<!-- 这里可写通用的实现逻辑 -->
5656

57+
**方法一：枚举上下边界 + 前缀和 + 哈希表**
58+
59+
我们可以枚举矩阵的上下边界 $i$ 和 $j$，每次算出当前上下边界内每列的元素和，记为数组 $col$，然后问题就转换为如何在数组 $col$ 中寻找和为目标值 $target$ 的子数组个数。我们累加这些子数组的个数，就是题目要求的答案。
60+
61+
那么题目就变成了：给定一个数组 $nums$ 和目标值 $target$，计算有多少个子数组的和为 $target$，我们可以通过函数 $f(nums, target)$ 来求解。
62+
63+
函数 $f(nums, target)$ 的计算方法如下：
64+
65+
- 定义一个哈希表 $d$，用来记录出现过的前缀和以及其出现次数，初始时 $d[0] = 1$；
66+
- 初始化变量 $s = 0, cnt = 0$，其中 $s$ 表示前缀和，而 $cnt$ 表示和为 $target$ 的子数组个数；
67+
- 从左到右遍历数组 $nums$，对于当前遍历到的元素 $x$，更新前缀和 $s = s + x$，如果 $d[s - target]$ 的值存在，那么更新 $cnt = cnt + d[s - target]$，即子数组个数增加 $d[s - target]$。然后更新哈希表中元素 $d[s]$ 的值，即 $d[s] = d[s] + 1$；继续遍历下一个元素；
68+
- 遍历结束之后，返回子数组个数 $cnt$。
69+
70+
时间复杂度 $O(m^2 \times n)$，空间复杂度 $O(n)$。其中 $m$ 和 $n$ 分别是矩阵的行数和列数。
71+
5772
<!-- tabs:start -->
5873

5974
### **Python3**
6075

6176
<!-- 这里可写当前语言的特殊实现逻辑 -->
6277

6378
```python
64-
79+
class Solution:
80+
def numSubmatrixSumTarget(self, matrix: List[List[int]], target: int) -> int:
81+
def f(nums: List[int]) -> int:
82+
d = defaultdict(int)
83+
d[0] = 1
84+
cnt = s = 0
85+
for x in nums:
86+
s += x
87+
cnt += d[s - target]
88+
d[s] += 1
89+
return cnt
90+
91+
m, n = len(matrix), len(matrix[0])
92+
ans = 0
93+
for i in range(m):
94+
col = [0] * n
95+
for j in range(i, m):
96+
for k in range(n):
97+
col[k] += matrix[j][k]
98+
ans += f(col)
99+
return ans
65100
```
66101

67102
### **Java**
68103

69104
<!-- 这里可写当前语言的特殊实现逻辑 -->
70105

71106
```java
107+
class Solution {
108+
public int numSubmatrixSumTarget(int[][] matrix, int target) {
109+
int m = matrix.length, n = matrix[0].length;
110+
int ans = 0;
111+
for (int i = 0; i < m; ++i) {
112+
int[] col = new int[n];
113+
for (int j = i; j < m; ++j) {
114+
for (int k = 0; k < n; ++k) {
115+
col[k] += matrix[j][k];
116+
}
117+
ans += f(col, target);
118+
}
119+
}
120+
return ans;
121+
}
122+
123+
private int f(int[] nums, int target) {
124+
Map<Integer, Integer> d = new HashMap<>();
125+
d.put(0, 1);
126+
int s = 0, cnt = 0;
127+
for (int x : nums) {
128+
s += x;
129+
cnt += d.getOrDefault(s - target, 0);
130+
d.merge(s, 1, Integer::sum);
131+
}
132+
return cnt;
133+
}
134+
}
135+
```
136+
137+
### **C++**
138+
139+
```cpp
140+
class Solution {
141+
public:
142+
int numSubmatrixSumTarget(vector<vector<int>>& matrix, int target) {
143+
int m = matrix.size(), n = matrix[0].size();
144+
int ans = 0;
145+
for (int i = 0; i < m; ++i) {
146+
vector<int> col(n);
147+
for (int j = i; j < m; ++j) {
148+
for (int k = 0; k < n; ++k) {
149+
col[k] += matrix[j][k];
150+
}
151+
ans += f(col, target);
152+
}
153+
}
154+
return ans;
155+
}
156+
157+
int f(vector<int>& nums, int target) {
158+
unordered_map<int, int> d{{0, 1}};
159+
int cnt = 0, s = 0;
160+
for (int& x : nums) {
161+
s += x;
162+
if (d.count(s - target)) {
163+
cnt += d[s - target];
164+
}
165+
++d[s];
166+
}
167+
return cnt;
168+
}
169+
};
170+
```
171+
172+
### **Go**
173+
174+
```go
175+
func numSubmatrixSumTarget(matrix [][]int, target int) (ans int) {
176+
m, n := len(matrix), len(matrix[0])
177+
for i := 0; i < m; i++ {
178+
col := make([]int, n)
179+
for j := i; j < m; j++ {
180+
for k := 0; k < n; k++ {
181+
col[k] += matrix[j][k]
182+
}
183+
ans += f(col, target)
184+
}
185+
}
186+
return
187+
}
188+
189+
func f(nums []int, target int) (cnt int) {
190+
d := map[int]int{0: 1}
191+
s := 0
192+
for _, x := range nums {
193+
s += x
194+
if v, ok := d[s-target]; ok {
195+
cnt += v
196+
}
197+
d[s]++
198+
}
199+
return
200+
}
201+
```
72202

203+
### **TypeScript**
204+
205+
```ts
206+
function numSubmatrixSumTarget(matrix: number[][], target: number): number {
207+
const m = matrix.length;
208+
const n = matrix[0].length;
209+
let ans = 0;
210+
for (let i = 0; i < m; ++i) {
211+
const col: number[] = new Array(n).fill(0);
212+
for (let j = i; j < m; ++j) {
213+
for (let k = 0; k < n; ++k) {
214+
col[k] += matrix[j][k];
215+
}
216+
ans += f(col, target);
217+
}
218+
}
219+
return ans;
220+
}
221+
222+
function f(nums: number[], target: number): number {
223+
const d: Map<number, number> = new Map();
224+
d.set(0, 1);
225+
let cnt = 0;
226+
let s = 0;
227+
for (const x of nums) {
228+
s += x;
229+
if (d.has(s - target)) {
230+
cnt += d.get(s - target)!;
231+
}
232+
d.set(s, (d.get(s) || 0) + 1);
233+
}
234+
return cnt;
235+
}
73236
```
74237

75238
### **...**

‎solution/1000-1099/1074.Number of Submatrices That Sum to Target/README_EN.md

+149-1
Original file line numberDiff line numberDiff line change
@@ -51,13 +51,161 @@
5151
### **Python3**
5252

5353
```python
54-
54+
class Solution:
55+
def numSubmatrixSumTarget(self, matrix: List[List[int]], target: int) -> int:
56+
def f(nums: List[int]) -> int:
57+
d = defaultdict(int)
58+
d[0] = 1
59+
cnt = s = 0
60+
for x in nums:
61+
s += x
62+
cnt += d[s - target]
63+
d[s] += 1
64+
return cnt
65+
66+
m, n = len(matrix), len(matrix[0])
67+
ans = 0
68+
for i in range(m):
69+
col = [0] * n
70+
for j in range(i, m):
71+
for k in range(n):
72+
col[k] += matrix[j][k]
73+
ans += f(col)
74+
return ans
5575
```
5676

5777
### **Java**
5878

5979
```java
80+
class Solution {
81+
public int numSubmatrixSumTarget(int[][] matrix, int target) {
82+
int m = matrix.length, n = matrix[0].length;
83+
int ans = 0;
84+
for (int i = 0; i < m; ++i) {
85+
int[] col = new int[n];
86+
for (int j = i; j < m; ++j) {
87+
for (int k = 0; k < n; ++k) {
88+
col[k] += matrix[j][k];
89+
}
90+
ans += f(col, target);
91+
}
92+
}
93+
return ans;
94+
}
95+
96+
private int f(int[] nums, int target) {
97+
Map<Integer, Integer> d = new HashMap<>();
98+
d.put(0, 1);
99+
int s = 0, cnt = 0;
100+
for (int x : nums) {
101+
s += x;
102+
cnt += d.getOrDefault(s - target, 0);
103+
d.merge(s, 1, Integer::sum);
104+
}
105+
return cnt;
106+
}
107+
}
108+
```
109+
110+
### **C++**
111+
112+
```cpp
113+
class Solution {
114+
public:
115+
int numSubmatrixSumTarget(vector<vector<int>>& matrix, int target) {
116+
int m = matrix.size(), n = matrix[0].size();
117+
int ans = 0;
118+
for (int i = 0; i < m; ++i) {
119+
vector<int> col(n);
120+
for (int j = i; j < m; ++j) {
121+
for (int k = 0; k < n; ++k) {
122+
col[k] += matrix[j][k];
123+
}
124+
ans += f(col, target);
125+
}
126+
}
127+
return ans;
128+
}
129+
130+
int f(vector<int>& nums, int target) {
131+
unordered_map<int, int> d{{0, 1}};
132+
int cnt = 0, s = 0;
133+
for (int& x : nums) {
134+
s += x;
135+
if (d.count(s - target)) {
136+
cnt += d[s - target];
137+
}
138+
++d[s];
139+
}
140+
return cnt;
141+
}
142+
};
143+
```
144+
145+
### **Go**
146+
147+
```go
148+
func numSubmatrixSumTarget(matrix [][]int, target int) (ans int) {
149+
m, n := len(matrix), len(matrix[0])
150+
for i := 0; i < m; i++ {
151+
col := make([]int, n)
152+
for j := i; j < m; j++ {
153+
for k := 0; k < n; k++ {
154+
col[k] += matrix[j][k]
155+
}
156+
ans += f(col, target)
157+
}
158+
}
159+
return
160+
}
161+
162+
func f(nums []int, target int) (cnt int) {
163+
d := map[int]int{0: 1}
164+
s := 0
165+
for _, x := range nums {
166+
s += x
167+
if v, ok := d[s-target]; ok {
168+
cnt += v
169+
}
170+
d[s]++
171+
}
172+
return
173+
}
174+
```
60175

176+
### **TypeScript**
177+
178+
```ts
179+
function numSubmatrixSumTarget(matrix: number[][], target: number): number {
180+
const m = matrix.length;
181+
const n = matrix[0].length;
182+
let ans = 0;
183+
for (let i = 0; i < m; ++i) {
184+
const col: number[] = new Array(n).fill(0);
185+
for (let j = i; j < m; ++j) {
186+
for (let k = 0; k < n; ++k) {
187+
col[k] += matrix[j][k];
188+
}
189+
ans += f(col, target);
190+
}
191+
}
192+
return ans;
193+
}
194+
195+
function f(nums: number[], target: number): number {
196+
const d: Map<number, number> = new Map();
197+
d.set(0, 1);
198+
let cnt = 0;
199+
let s = 0;
200+
for (const x of nums) {
201+
s += x;
202+
if (d.has(s - target)) {
203+
cnt += d.get(s - target)!;
204+
}
205+
d.set(s, (d.get(s) || 0) + 1);
206+
}
207+
return cnt;
208+
}
61209
```
62210

63211
### **...**

‎solution/1000-1099/1074.Number of Submatrices That Sum to Target/Solution.cpp

+30
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
class Solution {
2+
public:
3+
int numSubmatrixSumTarget(vector<vector<int>>& matrix, int target) {
4+
int m = matrix.size(), n = matrix[0].size();
5+
int ans = 0;
6+
for (int i = 0; i < m; ++i) {
7+
vector<int> col(n);
8+
for (int j = i; j < m; ++j) {
9+
for (int k = 0; k < n; ++k) {
10+
col[k] += matrix[j][k];
11+
}
12+
ans += f(col, target);
13+
}
14+
}
15+
return ans;
16+
}
17+
18+
int f(vector<int>& nums, int target) {
19+
unordered_map<int, int> d{{0, 1}};
20+
int cnt = 0, s = 0;
21+
for (int& x : nums) {
22+
s += x;
23+
if (d.count(s - target)) {
24+
cnt += d[s - target];
25+
}
26+
++d[s];
27+
}
28+
return cnt;
29+
}
30+
};

0 commit comments

Comments
 (0)