Skip to content

Commit e3313bf

Browse files
yanglbmeyanglbme
committedDec 24, 2022
feat: add solutions to lc problem: No.0823
No.0823.Binary Trees With Factors
·
v0.3.0v0.2.0
1 parent 61dc42c commit e3313bf

File tree

6 files changed

+341
-2
lines changed

6 files changed

+341
-2
lines changed
 

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

+122-1
Original file line numberDiff line numberDiff line change
@@ -42,22 +42,143 @@
4242

4343
<!-- 这里可写通用的实现逻辑 -->
4444

45+
**方法一：动态规划**
46+
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)$ 分别为左子树和右子树的二叉树个数。
48+
49+
因此，我们先将 `arr` 排序，然后用 $f[i]$ 表示以 $arr[i]$ 为根节点的二叉树的个数，最终答案即为 $f[0] + f[1] + \cdots + f[n - 1]$。
50+
51+
时间复杂度为 $O(n^2)$，空间复杂度为 $O(n)$。其中 $n$ 为 `arr` 的长度。
52+
4553
<!-- tabs:start -->
4654

4755
### **Python3**
4856

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

5159
```python
52-
60+
class Solution:
61+
def numFactoredBinaryTrees(self, arr: List[int]) -> int:
62+
mod = 10**9 + 7
63+
n = len(arr)
64+
arr.sort()
65+
idx = {v: i for i, v in enumerate(arr)}
66+
f = [1] * n
67+
for i, a in enumerate(arr):
68+
for j in range(i):
69+
b = arr[j]
70+
if a % b == 0 and (c := (a // b)) in idx:
71+
f[i] = (f[i] + f[j] * f[idx[c]]) % mod
72+
return sum(f) % mod
5373
```
5474

5575
### **Java**
5676

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

5979
```java
80+
class Solution {
81+
private static final int MOD = (int) 1e9 + 7;
82+
83+
public int numFactoredBinaryTrees(int[] arr) {
84+
Arrays.sort(arr);
85+
int n = arr.length;
86+
long[] f = new long[n];
87+
Arrays.fill(f, 1);
88+
Map<Integer, Integer> idx = new HashMap<>(n);
89+
for (int i = 0; i < n; ++i) {
90+
idx.put(arr[i], i);
91+
}
92+
for (int i = 0; i < n; ++i) {
93+
int a = arr[i];
94+
for (int j = 0; j < i; ++j) {
95+
int b = arr[j];
96+
if (a % b == 0) {
97+
int c = a / b;
98+
if (idx.containsKey(c)) {
99+
int k = idx.get(c);
100+
f[i] = (f[i] + f[j] * f[k]) % MOD;
101+
}
102+
}
103+
}
104+
}
105+
long ans = 0;
106+
for (long v : f) {
107+
ans = (ans + v) % MOD;
108+
}
109+
return (int) ans;
110+
}
111+
}
112+
```
113+
114+
### **C++**
115+
116+
```cpp
117+
class Solution {
118+
public:
119+
const int mod = 1e9 + 7;
120+
121+
int numFactoredBinaryTrees(vector<int>& arr) {
122+
sort(arr.begin(), arr.end());
123+
unordered_map<int, int> idx;
124+
int n = arr.size();
125+
for (int i = 0; i < n; ++i) {
126+
idx[arr[i]] = i;
127+
}
128+
vector<long> f(n, 1);
129+
for (int i = 0; i < n; ++i) {
130+
int a = arr[i];
131+
for (int j = 0; j < i; ++j) {
132+
int b = arr[j];
133+
if (a % b == 0) {
134+
int c = a / b;
135+
if (idx.count(c)) {
136+
int k = idx[c];
137+
f[i] = (f[i] + 1l * f[j] * f[k]) % mod;
138+
}
139+
}
140+
}
141+
}
142+
long ans = 0;
143+
for (long v : f) {
144+
ans = (ans + v) % mod;
145+
}
146+
return ans;
147+
}
148+
};
149+
```
60150
151+
### **Go**
152+
153+
```go
154+
func numFactoredBinaryTrees(arr []int) int {
155+
const mod int = 1e9 + 7
156+
sort.Ints(arr)
157+
f := make([]int, len(arr))
158+
for i := range f {
159+
f[i] = 1
160+
}
161+
idx := map[int]int{}
162+
for i, v := range arr {
163+
idx[v] = i
164+
}
165+
for i, a := range arr {
166+
for j := 0; j < i; j++ {
167+
b := arr[j]
168+
if a%b == 0 {
169+
c := a / b
170+
if k, ok := idx[c]; ok {
171+
f[i] = (f[i] + f[j]*f[k]) % mod
172+
}
173+
}
174+
}
175+
}
176+
ans := 0
177+
for _, v := range f {
178+
ans = (ans + v) % mod
179+
}
180+
return ans
181+
}
61182
```
62183

63184
### **...**

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

+114-1
Original file line numberDiff line numberDiff line change
@@ -41,13 +41,126 @@
4141
### **Python3**
4242

4343
```python
44-
44+
class Solution:
45+
def numFactoredBinaryTrees(self, arr: List[int]) -> int:
46+
mod = 10**9 + 7
47+
n = len(arr)
48+
arr.sort()
49+
idx = {v: i for i, v in enumerate(arr)}
50+
f = [1] * n
51+
for i, a in enumerate(arr):
52+
for j in range(i):
53+
b = arr[j]
54+
if a % b == 0 and (c := (a // b)) in idx:
55+
f[i] = (f[i] + f[j] * f[idx[c]]) % mod
56+
return sum(f) % mod
4557
```
4658

4759
### **Java**
4860

4961
```java
62+
class Solution {
63+
private static final int MOD = (int) 1e9 + 7;
64+
65+
public int numFactoredBinaryTrees(int[] arr) {
66+
Arrays.sort(arr);
67+
int n = arr.length;
68+
long[] f = new long[n];
69+
Arrays.fill(f, 1);
70+
Map<Integer, Integer> idx = new HashMap<>(n);
71+
for (int i = 0; i < n; ++i) {
72+
idx.put(arr[i], i);
73+
}
74+
for (int i = 0; i < n; ++i) {
75+
int a = arr[i];
76+
for (int j = 0; j < i; ++j) {
77+
int b = arr[j];
78+
if (a % b == 0) {
79+
int c = a / b;
80+
if (idx.containsKey(c)) {
81+
int k = idx.get(c);
82+
f[i] = (f[i] + f[j] * f[k]) % MOD;
83+
}
84+
}
85+
}
86+
}
87+
long ans = 0;
88+
for (long v : f) {
89+
ans = (ans + v) % MOD;
90+
}
91+
return (int) ans;
92+
}
93+
}
94+
```
95+
96+
### **C++**
97+
98+
```cpp
99+
class Solution {
100+
public:
101+
const int mod = 1e9 + 7;
102+
103+
int numFactoredBinaryTrees(vector<int>& arr) {
104+
sort(arr.begin(), arr.end());
105+
unordered_map<int, int> idx;
106+
int n = arr.size();
107+
for (int i = 0; i < n; ++i) {
108+
idx[arr[i]] = i;
109+
}
110+
vector<long> f(n, 1);
111+
for (int i = 0; i < n; ++i) {
112+
int a = arr[i];
113+
for (int j = 0; j < i; ++j) {
114+
int b = arr[j];
115+
if (a % b == 0) {
116+
int c = a / b;
117+
if (idx.count(c)) {
118+
int k = idx[c];
119+
f[i] = (f[i] + 1l * f[j] * f[k]) % mod;
120+
}
121+
}
122+
}
123+
}
124+
long ans = 0;
125+
for (long v : f) {
126+
ans = (ans + v) % mod;
127+
}
128+
return ans;
129+
}
130+
};
131+
```
50132
133+
### **Go**
134+
135+
```go
136+
func numFactoredBinaryTrees(arr []int) int {
137+
const mod int = 1e9 + 7
138+
sort.Ints(arr)
139+
f := make([]int, len(arr))
140+
for i := range f {
141+
f[i] = 1
142+
}
143+
idx := map[int]int{}
144+
for i, v := range arr {
145+
idx[v] = i
146+
}
147+
for i, a := range arr {
148+
for j := 0; j < i; j++ {
149+
b := arr[j]
150+
if a%b == 0 {
151+
c := a / b
152+
if k, ok := idx[c]; ok {
153+
f[i] = (f[i] + f[j]*f[k]) % mod
154+
}
155+
}
156+
}
157+
}
158+
ans := 0
159+
for _, v := range f {
160+
ans = (ans + v) % mod
161+
}
162+
return ans
163+
}
51164
```
52165

53166
### **...**

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

+32
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
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+
}
32+
}

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

+32
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
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+
}
32+
};

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

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
func numFactoredBinaryTrees(arr []int) int {
2+
const mod int = 1e9 + 7
3+
sort.Ints(arr)
4+
f := make([]int, len(arr))
5+
for i := range f {
6+
f[i] = 1
7+
}
8+
idx := map[int]int{}
9+
for i, v := range arr {
10+
idx[v] = i
11+
}
12+
for i, a := range arr {
13+
for j := 0; j < i; j++ {
14+
b := arr[j]
15+
if a%b == 0 {
16+
c := a / b
17+
if k, ok := idx[c]; ok {
18+
f[i] = (f[i] + f[j]*f[k]) % mod
19+
}
20+
}
21+
}
22+
}
23+
ans := 0
24+
for _, v := range f {
25+
ans = (ans + v) % mod
26+
}
27+
return ans
28+
}

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

+13
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
class Solution:
2+
def numFactoredBinaryTrees(self, arr: List[int]) -> int:
3+
mod = 10**9 + 7
4+
n = len(arr)
5+
arr.sort()
6+
idx = {v: i for i, v in enumerate(arr)}
7+
f = [1] * n
8+
for i, a in enumerate(arr):
9+
for j in range(i):
10+
b = arr[j]
11+
if a % b == 0 and (c := (a // b)) in idx:
12+
f[i] = (f[i] + f[j] * f[idx[c]]) % mod
13+
return sum(f) % mod

0 commit comments

Comments
 (0)
Please sign in to comment.