Sponsored
Sponsored
The greedy DFS solution is based on a bottom-up approach. We classify each node into one of three states: covered by a camera, has a camera, or needs a camera. A node needs a camera if its children are not covered. We use a post-order DFS strategy to ensure all children are addressed before deciding the current node's state. The optimal way to cover a subtree is to place a camera on nodes whose children are not covered.
Time Complexity: O(n), where n is the number of nodes in the tree, due to the DFS traversal of every node.
Space Complexity: O(h), where h is the height of the tree, due to the recursion stack space.
1#include <stdio.h>
2#include <stdlib.h>
3
4struct TreeNode {
5 int val;
6 struct TreeNode *left;
7 struct TreeNode *right;
8};
9
10int minCameras;
11
12int dfs(struct TreeNode* node) {
13 if (!node) return 2; // if null, considered covered
14
15 int left = dfs(node->left);
16 int right = dfs(node->right);
17
18 if (left == 0 || right == 0) {
19 minCameras++;
20 return 1; // install camera
21 }
22 return (left == 1 || right == 1) ? 2 : 0;
23}
24
25int minCameraCover(struct TreeNode* root) {
26 minCameras = 0;
27 return (dfs(root) == 0 ? 1 : 0) + minCameras;
28}The code uses a post-order DFS traversal. It installs a camera at a node if either of its children need a camera (state 0). At the end, if the root itself needs a camera, we increment the count by one. Each node returns a state: 0 if it needs coverage, 1 if it has a camera, and 2 if it's covered.
This approach leverages dynamic programming through a recursive function with memoization to reduce redundant calculations. Each node can have three states represented in a tuple: it has a camera, it's covered but doesn't have a camera, or it's not covered. Using this state information, the solution calculates camera placements strategically.
Time Complexity: O(n), where n is the number of nodes.
Space Complexity: O(n), due to memoization storage.
1from functools import lru_cache
2
3class TreeNode:
4 def
This solution uses dynamic programming with memoization to avoid redundant recursive calls. The function `dfs` returns a tuple of three states for each node: the cost of having a camera, being covered without a camera, and not being covered.
The first element, `dp0`, calculates cost when a camera is placed at the current node. The second, `dp1`, calculates when the node is covered without having a camera, and the third, `dp2`, calculates when the node itself isn't covered.