Given the root of a binary tree, return the sum of every tree node's tilt.
The tilt of a tree node is the absolute difference between the sum of all left subtree node values and all right subtree node values. If a node does not have a left child, then the sum of the left subtree node values is treated as 0. The rule is similar if the node does not have a right child.
Example 1:
Input: root = [1,2,3]
Output: 1
Explanation:
Tilt of node 2 : |0-0| = 0 (no children)
Tilt of node 3 : |0-0| = 0 (no children)
Tilt of node 1 : |2-3| = 1 (left subtree is just left child, so sum is 2; right subtree is just right child, so sum is 3)
Sum of every tilt : 0 + 0 + 1 = 1
Example 2:
Input: root = [4,2,9,3,5,null,7]
Output: 15
Explanation:
Tilt of node 3 : |0-0| = 0 (no children)
Tilt of node 5 : |0-0| = 0 (no children)
Tilt of node 7 : |0-0| = 0 (no children)
Tilt of node 2 : |3-5| = 2 (left subtree is just left child, so sum is 3; right subtree is just right child, so sum is 5)
Tilt of node 9 : |0-7| = 7 (no left child, so sum is 0; right subtree is just right child, so sum is 7)
Tilt of node 4 : |(3+5+2)-(9+7)| = |10-16| = 6 (left subtree values are 3, 5, and 2, which sums to 10; right subtree values are 9 and 7, which sums to 16)
Sum of every tilt : 0 + 0 + 0 + 2 + 7 + 6 = 15
Example 3:
Input: root = [21,7,14,1,1,2,2,3,3]
Output: 9
Constraints:
- The number of nodes in the tree is in the range [0, 104].
- -1000 <= Node.val <= 1000
My Solution
We first compute the sums of all the subtrees and store them in a HashMap. We then do a breadth first search across the tree to find the absolute difference between the left subtree sum and right subtree sum across all nodes in the tree. We return this sum.
Time complexity is O(n), where n is the number of nodes in the tree because we visit every node while we compute the sums of all subtrees. We also traverse every node once when doing the breadth first traversal. Space complexity is O(n) due to the space required for the sums HashMap as well as the space required for the queue in our breadth first traversal.
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int findTilt(TreeNode root) {
if (root == null) {
return 0;
}
Map<TreeNode,Integer> sums = new HashMap<>();
Deque<TreeNode> q = new ArrayDeque<>();
int sum = 0;
sum(root, sums);
q.add(root);
while (!q.isEmpty()) {
int size = q.size();
for (int i = 0; i < size; i++) {
TreeNode n = q.removeFirst();
int left = 0;
int right = 0;
if (n.left != null) {
left += sums.get(n.left);
q.add(n.left);
}
if (n.right != null) {
right += sums.get(n.right);
q.add(n.right);
}
sum += Math.abs(left-right);
}
}
return sum;
}
public int sum(TreeNode root, Map<TreeNode,Integer> sums) {
if (root == null) {
return 0;
}
int sum = root.val + sum(root.left, sums) + sum(root.right, sums);
sums.put(root, sum);
return sum;
}
}