Skip to content

Commit d2376fc

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0968
No.0968.Binary Tree Cameras
1 parent a23747d commit d2376fc

File tree

6 files changed

+387
-61
lines changed

6 files changed

+387
-61
lines changed

‎solution/0900-0999/0968.Binary Tree Cameras/README.md

+143-30
Original file line numberDiff line numberDiff line change
@@ -44,22 +44,144 @@
4444

4545
<!-- 这里可写通用的实现逻辑 -->
4646

47+
贪心 + DFS。
48+
49+
我们知道，
50+
51+
1. 如果在叶子节点放置摄像头，摄像头会覆盖当前叶子节点以及它的父节点；
52+
1. 如果在非叶子节点放置摄像头，摄像头会覆盖当前节点、它的子节点以及它的父节点。
53+
54+
第二种方案始终优于第一种方案。
55+
56+
因此，一种贪心的解法是，将摄像头放置在叶子节点的父节点上，然后移除所有被覆盖的节点，重复这一步骤，直至所有节点被移除。
57+
58+
我们用数字 0, 1, 2 表示每个节点可能的三种状态，
59+
60+
- 0: 叶子节点
61+
- 1: 叶子节点的父节点，并且放置了摄像头
62+
- 2: 没放置摄像头，但是被摄像头覆盖
63+
64+
定义 dfs(node) 返回每个节点的状态，对于每个节点，
65+
66+
1. 如果存在子节点，并且是叶子节点(`left == 0 || right == 0`)，那么该节点需要放置摄像头，累加摄像头 ans，返回 1；
67+
1. 如果存在子节点，并且子节点放置了摄像头(`left == 1 || right == 1`)，那么该节点可以直接被覆盖，返回 2；
68+
1. 否则把当前节点视为叶子节点，继续向上递归。
69+
70+
判断 `dfs(root)` 结果，若等于 0，说明还存在当前这一个叶子节点未被覆盖，摄像头数量 ans + 1 并返回，否则返回 ans。
71+
4772
<!-- tabs:start -->
4873

4974
### **Python3**
5075

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

5378
```python
54-
79+
# Definition for a binary tree node.
80+
# class TreeNode:
81+
# def __init__(self, val=0, left=None, right=None):
82+
# self.val = val
83+
# self.left = left
84+
# self.right = right
85+
class Solution:
86+
def minCameraCover(self, root: TreeNode) -> int:
87+
def dfs(root):
88+
nonlocal ans
89+
if root is None:
90+
return 2
91+
left, right = dfs(root.left), dfs(root.right)
92+
if left == 0 or right == 0:
93+
ans += 1
94+
return 1
95+
return 2 if left == 1 or right == 1 else 0
96+
97+
ans = 0
98+
return (dfs(root) == 0) + ans
5599
```
56100

57101
### **Java**
58102

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

61105
```java
106+
/**
107+
* Definition for a binary tree node.
108+
* public class TreeNode {
109+
* int val;
110+
* TreeNode left;
111+
* TreeNode right;
112+
* TreeNode() {}
113+
* TreeNode(int val) { this.val = val; }
114+
* TreeNode(int val, TreeNode left, TreeNode right) {
115+
* this.val = val;
116+
* this.left = left;
117+
* this.right = right;
118+
* }
119+
* }
120+
*/
121+
class Solution {
62122

123+
private int ans;
124+
125+
public int minCameraCover(TreeNode root) {
126+
ans = 0;
127+
return (dfs(root) == 0) ? ans + 1 : ans;
128+
}
129+
130+
private int dfs(TreeNode root) {
131+
if (root == null) {
132+
return 2;
133+
}
134+
int left = dfs(root.left);
135+
int right = dfs(root.right);
136+
if (left == 0 || right == 0) {
137+
++ans;
138+
return 1;
139+
}
140+
if (left == 1 || right == 1) {
141+
return 2;
142+
}
143+
return 0;
144+
}
145+
}
146+
147+
```
148+
149+
### **C++**
150+
151+
```cpp
152+
/**
153+
* Definition for a binary tree node.
154+
* struct TreeNode {
155+
* int val;
156+
* TreeNode *left;
157+
* TreeNode *right;
158+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
159+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
160+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
161+
* };
162+
*/
163+
class Solution {
164+
public:
165+
int ans;
166+
167+
int minCameraCover(TreeNode* root) {
168+
ans = 0;
169+
if (dfs(root) == 0) return ans + 1;
170+
return ans;
171+
}
172+
173+
int dfs(TreeNode* root) {
174+
if (!root) return 2;
175+
int left = dfs(root->left), right = dfs(root->right);
176+
if (left == 0 || right == 0)
177+
{
178+
++ans;
179+
return 1;
180+
}
181+
if (left == 1 || right == 1) return 2;
182+
return 0;
183+
}
184+
};
63185
```
64186
65187
### **Go**
@@ -73,36 +195,27 @@
73195
* Right *TreeNode
74196
* }
75197
*/
76-
77-
var res int
78198
func minCameraCover(root *TreeNode) int {
79-
res = 0
80-
//三种状态，后序遍历
81-
if root == nil {
82-
return 0
83-
}
84-
if dfs(root) == 0 {
85-
res++
86-
}
87-
return res
88-
}
89-
//0:待覆盖，1：已覆盖，2：安装
90-
91-
func dfs(root *TreeNode) int {
92-
if root == nil {
93-
return 1
94-
}
95-
l := dfs(root.Left)
96-
r := dfs(root.Right)
97-
//左右子节点存在待覆盖状态，当前节点要安装
98-
if l == 0 || r == 0 {
99-
res++
100-
return 2
101-
} else if l == 1 && r == 1 { //左右节点均为已覆盖，则当前节点为待覆盖
102-
return 0
103-
}
104-
//除上述情况外，左右子节点中至少有一个安装了监控，当前节点为已覆盖
105-
return 1
199+
ans := 0
200+
var dfs func(root *TreeNode) int
201+
dfs = func(root *TreeNode) int {
202+
if root == nil {
203+
return 2
204+
}
205+
left, right := dfs(root.Left), dfs(root.Right)
206+
if left == 0 || right == 0 {
207+
ans++
208+
return 1
209+
}
210+
if left == 1 || right == 1 {
211+
return 2
212+
}
213+
return 0
214+
}
215+
if dfs(root) == 0 {
216+
return ans + 1
217+
}
218+
return ans
106219
}
107220
```
108221

‎solution/0900-0999/0968.Binary Tree Cameras/README_EN.md

+131-1
Original file line numberDiff line numberDiff line change
@@ -64,13 +64,143 @@
6464
### **Python3**
6565

6666
```python
67-
67+
# Definition for a binary tree node.
68+
# class TreeNode:
69+
# def __init__(self, val=0, left=None, right=None):
70+
# self.val = val
71+
# self.left = left
72+
# self.right = right
73+
class Solution:
74+
def minCameraCover(self, root: TreeNode) -> int:
75+
def dfs(root):
76+
nonlocal ans
77+
if root is None:
78+
return 2
79+
left, right = dfs(root.left), dfs(root.right)
80+
if left == 0 or right == 0:
81+
ans += 1
82+
return 1
83+
return 2 if left == 1 or right == 1 else 0
84+
85+
ans = 0
86+
return (dfs(root) == 0) + ans
6887
```
6988

7089
### **Java**
7190

7291
```java
92+
/**
93+
* Definition for a binary tree node.
94+
* public class TreeNode {
95+
* int val;
96+
* TreeNode left;
97+
* TreeNode right;
98+
* TreeNode() {}
99+
* TreeNode(int val) { this.val = val; }
100+
* TreeNode(int val, TreeNode left, TreeNode right) {
101+
* this.val = val;
102+
* this.left = left;
103+
* this.right = right;
104+
* }
105+
* }
106+
*/
107+
class Solution {
108+
private int ans;
109+
110+
public int minCameraCover(TreeNode root) {
111+
ans = 0;
112+
return (dfs(root) == 0) ? ans + 1 : ans;
113+
}
114+
115+
private int dfs(TreeNode root) {
116+
if (root == null) {
117+
return 2;
118+
}
119+
int left = dfs(root.left);
120+
int right = dfs(root.right);
121+
if (left == 0 || right == 0) {
122+
++ans;
123+
return 1;
124+
}
125+
if (left == 1 || right == 1) {
126+
return 2;
127+
}
128+
return 0;
129+
}
130+
}
131+
```
132+
133+
### **C++**
134+
135+
```cpp
136+
/**
137+
* Definition for a binary tree node.
138+
* struct TreeNode {
139+
* int val;
140+
* TreeNode *left;
141+
* TreeNode *right;
142+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
143+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
144+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
145+
* };
146+
*/
147+
class Solution {
148+
public:
149+
int ans;
150+
151+
int minCameraCover(TreeNode* root) {
152+
ans = 0;
153+
if (dfs(root) == 0) return ans + 1;
154+
return ans;
155+
}
156+
157+
int dfs(TreeNode* root) {
158+
if (!root) return 2;
159+
int left = dfs(root->left), right = dfs(root->right);
160+
if (left == 0 || right == 0)
161+
{
162+
++ans;
163+
return 1;
164+
}
165+
if (left == 1 || right == 1) return 2;
166+
return 0;
167+
}
168+
};
169+
```
73170
171+
### **Go**
172+
173+
```go
174+
/**
175+
* Definition for a binary tree node.
176+
* type TreeNode struct {
177+
* Val int
178+
* Left *TreeNode
179+
* Right *TreeNode
180+
* }
181+
*/
182+
func minCameraCover(root *TreeNode) int {
183+
ans := 0
184+
var dfs func(root *TreeNode) int
185+
dfs = func(root *TreeNode) int {
186+
if root == nil {
187+
return 2
188+
}
189+
left, right := dfs(root.Left), dfs(root.Right)
190+
if left == 0 || right == 0 {
191+
ans++
192+
return 1
193+
}
194+
if left == 1 || right == 1 {
195+
return 2
196+
}
197+
return 0
198+
}
199+
if dfs(root) == 0 {
200+
return ans + 1
201+
}
202+
return ans
203+
}
74204
```
75205

76206
### **...**

‎solution/0900-0999/0968.Binary Tree Cameras/Solution.cpp

+33
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10+
* };
11+
*/
12+
class Solution {
13+
public:
14+
int ans;
15+
16+
int minCameraCover(TreeNode* root) {
17+
ans = 0;
18+
if (dfs(root) == 0) return ans + 1;
19+
return ans;
20+
}
21+
22+
int dfs(TreeNode* root) {
23+
if (!root) return 2;
24+
int left = dfs(root->left), right = dfs(root->right);
25+
if (left == 0 || right == 0)
26+
{
27+
++ans;
28+
return 1;
29+
}
30+
if (left == 1 || right == 1) return 2;
31+
return 0;
32+
}
33+
};

0 commit comments

Comments
 (0)