Skip to content

Commit 7115c2e

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.0823 (#1536)
No.0823.Binary Trees With Factors
1 parent 92dbea0 commit 7115c2e

File tree

6 files changed

+159
-92
lines changed

6 files changed

+159
-92
lines changed

‎solution/0800-0899/0823.Binary Trees With Factors/README.md

+38-14
Original file line numberDiff line numberDiff line change
@@ -44,11 +44,11 @@
4444

4545
**方法一：动态规划**
4646

47-
我们可以枚举 `arr` 中的每一个数 $a$ 作为二叉树的根节点（根节点一定最大），然后枚举枚举左子树的值 $b$，若 $a$ 能被 $b$ 整除，则右子树的值为 $a / b$，若 $a / b$ 也在 `arr` 中，则可以构成一棵二叉树。此时，以 $a$ 为根节点的二叉树的个数为 $f(a) = f(b) \times f(a / b)$，其中 $f(b)$ 和 $f(a / b)$ 分别为左子树和右子树的二叉树个数。
47+
我们可以枚举 $arr$ 中的每一个数 $a$ 作为二叉树的根节点（根节点一定最大），然后枚举枚举左子树的值 $b$，若 $a$ 能被 $b$ 整除，则右子树的值为 $a / b$，若 $a / b$ 也在 $arr$ 中，则可以构成一棵二叉树。此时，以 $a$ 为根节点的二叉树的个数为 $f(a) = f(b) \times f(a / b)$，其中 $f(b)$ 和 $f(a / b)$ 分别为左子树和右子树的二叉树个数。
4848

49-
因此，我们先将 `arr` 排序，然后用 $f[i]$ 表示以 $arr[i]$ 为根节点的二叉树的个数，最终答案即为 $f[0] + f[1] + \cdots + f[n - 1]$。
49+
因此，我们先将 $arr$ 排序，然后用 $f[i]$ 表示以 $arr[i]$ 为根节点的二叉树的个数，最终答案即为 $f[0] + f[1] + \cdots + f[n - 1]$。注意答案可能很大，需要对 $10^9 + 7$ 取模。
5050

51-
时间复杂度为 $O(n^2)$，空间复杂度为 $O(n)$。其中 $n$ 为 `arr` 的长度。
51+
时间复杂度为 $O(n^2)$，空间复杂度为 $O(n)$。其中 $n$ 为 $arr$ 的长度。
5252

5353
<!-- tabs:start -->
5454

@@ -78,9 +78,8 @@ class Solution:
7878

7979
```java
8080
class Solution {
81-
private static final int MOD = (int) 1e9 + 7;
82-
8381
public int numFactoredBinaryTrees(int[] arr) {
82+
final int mod = (int) 1e9 + 7;
8483
Arrays.sort(arr);
8584
int n = arr.length;
8685
long[] f = new long[n];
@@ -97,14 +96,14 @@ class Solution {
9796
int c = a / b;
9897
if (idx.containsKey(c)) {
9998
int k = idx.get(c);
100-
f[i] = (f[i] + f[j] * f[k]) % MOD;
99+
f[i] = (f[i] + f[j] * f[k]) % mod;
101100
}
102101
}
103102
}
104103
}
105104
long ans = 0;
106105
for (long v : f) {
107-
ans = (ans + v) % MOD;
106+
ans = (ans + v) % mod;
108107
}
109108
return (int) ans;
110109
}
@@ -116,9 +115,8 @@ class Solution {
116115
```cpp
117116
class Solution {
118117
public:
119-
const int mod = 1e9 + 7;
120-
121118
int numFactoredBinaryTrees(vector<int>& arr) {
119+
const int mod = 1e9 + 7;
122120
sort(arr.begin(), arr.end());
123121
unordered_map<int, int> idx;
124122
int n = arr.size();
@@ -155,18 +153,15 @@ func numFactoredBinaryTrees(arr []int) int {
155153
const mod int = 1e9 + 7
156154
sort.Ints(arr)
157155
f := make([]int, len(arr))
158-
for i := range f {
159-
f[i] = 1
160-
}
161156
idx := map[int]int{}
162157
for i, v := range arr {
158+
f[i] = 1
163159
idx[v] = i
164160
}
165161
for i, a := range arr {
166162
for j := 0; j < i; j++ {
167163
b := arr[j]
168-
if a%b == 0 {
169-
c := a / b
164+
if c := a / b; a%b == 0 {
170165
if k, ok := idx[c]; ok {
171166
f[i] = (f[i] + f[j]*f[k]) % mod
172167
}
@@ -181,6 +176,35 @@ func numFactoredBinaryTrees(arr []int) int {
181176
}
182177
```
183178

179+
### **TypeScript**
180+
181+
```ts
182+
function numFactoredBinaryTrees(arr: number[]): number {
183+
const mod = 10 ** 9 + 7;
184+
arr.sort((a, b) => a - b);
185+
const idx: Map<number, number> = new Map();
186+
const n = arr.length;
187+
for (let i = 0; i < n; ++i) {
188+
idx.set(arr[i], i);
189+
}
190+
const f: number[] = new Array(n).fill(1);
191+
for (let i = 0; i < n; ++i) {
192+
const a = arr[i];
193+
for (let j = 0; j < i; ++j) {
194+
const b = arr[j];
195+
if (a % b === 0) {
196+
const c = a / b;
197+
if (idx.has(c)) {
198+
const k = idx.get(c)!;
199+
f[i] = (f[i] + f[j] * f[k]) % mod;
200+
}
201+
}
202+
}
203+
}
204+
return f.reduce((a, b) => a + b) % mod;
205+
}
206+
```
207+
184208
### **...**
185209

186210
```

‎solution/0800-0899/0823.Binary Trees With Factors/README_EN.md

+35-11
Original file line numberDiff line numberDiff line change
@@ -60,9 +60,8 @@ class Solution:
6060

6161
```java
6262
class Solution {
63-
private static final int MOD = (int) 1e9 + 7;
64-
6563
public int numFactoredBinaryTrees(int[] arr) {
64+
final int mod = (int) 1e9 + 7;
6665
Arrays.sort(arr);
6766
int n = arr.length;
6867
long[] f = new long[n];
@@ -79,14 +78,14 @@ class Solution {
7978
int c = a / b;
8079
if (idx.containsKey(c)) {
8180
int k = idx.get(c);
82-
f[i] = (f[i] + f[j] * f[k]) % MOD;
81+
f[i] = (f[i] + f[j] * f[k]) % mod;
8382
}
8483
}
8584
}
8685
}
8786
long ans = 0;
8887
for (long v : f) {
89-
ans = (ans + v) % MOD;
88+
ans = (ans + v) % mod;
9089
}
9190
return (int) ans;
9291
}
@@ -98,9 +97,8 @@ class Solution {
9897
```cpp
9998
class Solution {
10099
public:
101-
const int mod = 1e9 + 7;
102-
103100
int numFactoredBinaryTrees(vector<int>& arr) {
101+
const int mod = 1e9 + 7;
104102
sort(arr.begin(), arr.end());
105103
unordered_map<int, int> idx;
106104
int n = arr.size();
@@ -137,18 +135,15 @@ func numFactoredBinaryTrees(arr []int) int {
137135
const mod int = 1e9 + 7
138136
sort.Ints(arr)
139137
f := make([]int, len(arr))
140-
for i := range f {
141-
f[i] = 1
142-
}
143138
idx := map[int]int{}
144139
for i, v := range arr {
140+
f[i] = 1
145141
idx[v] = i
146142
}
147143
for i, a := range arr {
148144
for j := 0; j < i; j++ {
149145
b := arr[j]
150-
if a%b == 0 {
151-
c := a / b
146+
if c := a / b; a%b == 0 {
152147
if k, ok := idx[c]; ok {
153148
f[i] = (f[i] + f[j]*f[k]) % mod
154149
}
@@ -163,6 +158,35 @@ func numFactoredBinaryTrees(arr []int) int {
163158
}
164159
```
165160

161+
### **TypeScript**
162+
163+
```ts
164+
function numFactoredBinaryTrees(arr: number[]): number {
165+
const mod = 10 ** 9 + 7;
166+
arr.sort((a, b) => a - b);
167+
const idx: Map<number, number> = new Map();
168+
const n = arr.length;
169+
for (let i = 0; i < n; ++i) {
170+
idx.set(arr[i], i);
171+
}
172+
const f: number[] = new Array(n).fill(1);
173+
for (let i = 0; i < n; ++i) {
174+
const a = arr[i];
175+
for (let j = 0; j < i; ++j) {
176+
const b = arr[j];
177+
if (a % b === 0) {
178+
const c = a / b;
179+
if (idx.has(c)) {
180+
const k = idx.get(c)!;
181+
f[i] = (f[i] + f[j] * f[k]) % mod;
182+
}
183+
}
184+
}
185+
}
186+
return f.reduce((a, b) => a + b) % mod;
187+
}
188+
```
189+
166190
### **...**
167191

168192
```

‎solution/0800-0899/0823.Binary Trees With Factors/Solutioin.java

+30-31
Original file line numberDiff line numberDiff line change
@@ -1,32 +1,31 @@
1-
class Solution {
2-
private static final int MOD = (int) 1e9 + 7;
3-
4-
public int numFactoredBinaryTrees(int[] arr) {
5-
Arrays.sort(arr);
6-
int n = arr.length;
7-
long[] f = new long[n];
8-
Arrays.fill(f, 1);
9-
Map<Integer, Integer> idx = new HashMap<>(n);
10-
for (int i = 0; i < n; ++i) {
11-
idx.put(arr[i], i);
12-
}
13-
for (int i = 0; i < n; ++i) {
14-
int a = arr[i];
15-
for (int j = 0; j < i; ++j) {
16-
int b = arr[j];
17-
if (a % b == 0) {
18-
int c = a / b;
19-
if (idx.containsKey(c)) {
20-
int k = idx.get(c);
21-
f[i] = (f[i] + f[j] * f[k]) % MOD;
22-
}
23-
}
24-
}
25-
}
26-
long ans = 0;
27-
for (long v : f) {
28-
ans = (ans + v) % MOD;
29-
}
30-
return (int) ans;
31-
}
1+
class Solution {
2+
public int numFactoredBinaryTrees(int[] arr) {
3+
final int mod = (int) 1e9 + 7;
4+
Arrays.sort(arr);
5+
int n = arr.length;
6+
long[] f = new long[n];
7+
Arrays.fill(f, 1);
8+
Map<Integer, Integer> idx = new HashMap<>(n);
9+
for (int i = 0; i < n; ++i) {
10+
idx.put(arr[i], i);
11+
}
12+
for (int i = 0; i < n; ++i) {
13+
int a = arr[i];
14+
for (int j = 0; j < i; ++j) {
15+
int b = arr[j];
16+
if (a % b == 0) {
17+
int c = a / b;
18+
if (idx.containsKey(c)) {
19+
int k = idx.get(c);
20+
f[i] = (f[i] + f[j] * f[k]) % mod;
21+
}
22+
}
23+
}
24+
}
25+
long ans = 0;
26+
for (long v : f) {
27+
ans = (ans + v) % mod;
28+
}
29+
return (int) ans;
30+
}
3231
}

‎solution/0800-0899/0823.Binary Trees With Factors/Solution.cpp

+30-31
Original file line numberDiff line numberDiff line change
@@ -1,32 +1,31 @@
1-
class Solution {
2-
public:
3-
const int mod = 1e9 + 7;
4-
5-
int numFactoredBinaryTrees(vector<int>& arr) {
6-
sort(arr.begin(), arr.end());
7-
unordered_map<int, int> idx;
8-
int n = arr.size();
9-
for (int i = 0; i < n; ++i) {
10-
idx[arr[i]] = i;
11-
}
12-
vector<long> f(n, 1);
13-
for (int i = 0; i < n; ++i) {
14-
int a = arr[i];
15-
for (int j = 0; j < i; ++j) {
16-
int b = arr[j];
17-
if (a % b == 0) {
18-
int c = a / b;
19-
if (idx.count(c)) {
20-
int k = idx[c];
21-
f[i] = (f[i] + 1l * f[j] * f[k]) % mod;
22-
}
23-
}
24-
}
25-
}
26-
long ans = 0;
27-
for (long v : f) {
28-
ans = (ans + v) % mod;
29-
}
30-
return ans;
31-
}
1+
class Solution {
2+
public:
3+
int numFactoredBinaryTrees(vector<int>& arr) {
4+
const int mod = 1e9 + 7;
5+
sort(arr.begin(), arr.end());
6+
unordered_map<int, int> idx;
7+
int n = arr.size();
8+
for (int i = 0; i < n; ++i) {
9+
idx[arr[i]] = i;
10+
}
11+
vector<long> f(n, 1);
12+
for (int i = 0; i < n; ++i) {
13+
int a = arr[i];
14+
for (int j = 0; j < i; ++j) {
15+
int b = arr[j];
16+
if (a % b == 0) {
17+
int c = a / b;
18+
if (idx.count(c)) {
19+
int k = idx[c];
20+
f[i] = (f[i] + 1l * f[j] * f[k]) % mod;
21+
}
22+
}
23+
}
24+
}
25+
long ans = 0;
26+
for (long v : f) {
27+
ans = (ans + v) % mod;
28+
}
29+
return ans;
30+
}
3231
};

‎solution/0800-0899/0823.Binary Trees With Factors/Solution.go

+2-5
Original file line numberDiff line numberDiff line change
@@ -2,18 +2,15 @@ func numFactoredBinaryTrees(arr []int) int {
22
const mod int = 1e9 + 7
33
sort.Ints(arr)
44
f := make([]int, len(arr))
5-
for i := range f {
6-
f[i] = 1
7-
}
85
idx := map[int]int{}
96
for i, v := range arr {
7+
f[i] = 1
108
idx[v] = i
119
}
1210
for i, a := range arr {
1311
for j := 0; j < i; j++ {
1412
b := arr[j]
15-
if a%b == 0 {
16-
c := a / b
13+
if c := a / b; a%b == 0 {
1714
if k, ok := idx[c]; ok {
1815
f[i] = (f[i] + f[j]*f[k]) % mod
1916
}

‎solution/0800-0899/0823.Binary Trees With Factors/Solution.ts

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
function numFactoredBinaryTrees(arr: number[]): number {
2+
const mod = 10 ** 9 + 7;
3+
arr.sort((a, b) => a - b);
4+
const idx: Map<number, number> = new Map();
5+
const n = arr.length;
6+
for (let i = 0; i < n; ++i) {
7+
idx.set(arr[i], i);
8+
}
9+
const f: number[] = new Array(n).fill(1);
10+
for (let i = 0; i < n; ++i) {
11+
const a = arr[i];
12+
for (let j = 0; j < i; ++j) {
13+
const b = arr[j];
14+
if (a % b === 0) {
15+
const c = a / b;
16+
if (idx.has(c)) {
17+
const k = idx.get(c)!;
18+
f[i] = (f[i] + f[j] * f[k]) % mod;
19+
}
20+
}
21+
}
22+
}
23+
return f.reduce((a, b) => a + b) % mod;
24+
}

0 commit comments

Comments
 (0)