add 2049

Author: fishercoder1534

paginated_contents/algorithms/3rd_thousand/README.md

@@ -177,6 +177,7 @@
 | 2054 | [Two Best Non-Overlapping Events](https://leetcode.com/problems/two-best-non-overlapping-events/)                                                                                             | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2054.java)                                       || Medium                               ||
 | 2053 | [Kth Distinct String in an Array](https://leetcode.com/problems/kth-distinct-string-in-an-array/)                                                                                             | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2053.java)                                       || Easy                                 ||
 | 2050 | [Parallel Courses III](https://leetcode.com/problems/parallel-courses-iii/)                                                                                                                   | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2050.java)                                       || Hard                                 ||
+| 2049 | [Count Nodes With the Highest Score](https://leetcode.com/problems/count-nodes-with-the-highest-score/)                                                                                                                   | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2049.java)                                       || Medium                               |DFS, Tree
 | 2048 | [Next Greater Numerically Balanced Number](https://leetcode.com/problems/next-greater-numerically-balanced-number/)                                                                           | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2048.java)                                       || Medium                               ||
 | 2047 | [Number of Valid Words in a Sentence](https://leetcode.com/problems/number-of-valid-words-in-a-sentence/)                                                                                     | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2047.java)                                       || Easy                                 ||
 | 2044 | [Count Number of Maximum Bitwise-OR Subsets](https://leetcode.com/problems/count-number-of-maximum-bitwise-or-subsets/)                                                                       | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2044.java)                                       || Medium                               ||

src/main/java/com/fishercoder/solutions/thirdthousand/_2049.java

@@ -0,0 +1,95 @@
+package com.fishercoder.solutions.thirdthousand;
+
+import com.fishercoder.common.classes.TreeNode;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class _2049 {
+    public static class Solution1 {
+        /**
+         * My completely original solution.
+         * Practice makes perfect!
+         */
+        public int countHighestScoreNodes(int[] parents) {
+            Map<Integer, TreeNode> valToNodeMap = new HashMap<>();
+            TreeNode root = buildBinaryTree(parents, valToNodeMap);
+
+            //it'll be handy if we can cache the number of children each node has as we'll do this many times, so we can quickly calculate the score for each node
+            //key is the node since each node's value is unique, value if the number of children this node has
+            Map<Integer, Long> nodeCountMap = new HashMap<>();
+            //naturally we should use post-order traversal since we need to count the children for each child first, then we can roll up to add one to get the number of children for the root node
+            long allNodeCount = postOrder(root, nodeCountMap);
+            nodeCountMap.put(root.val, allNodeCount);
+
+            //now calculate the score of each node
+            List<Long> scoreList = new ArrayList<>();
+            long highestScore = 0;
+            for (int i = 0; i < parents.length; i++) {
+                long score = computeScore(i, nodeCountMap, valToNodeMap);
+                highestScore = Math.max(score, highestScore);
+                scoreList.add(score);
+            }
+            int count = 0;
+            for (long score : scoreList) {
+                if (score == highestScore) {
+                    count++;
+                }
+            }
+            return count;
+        }
+
+        private Long computeScore(int nodeVal, Map<Integer, Long> nodeCountMap, Map<Integer, TreeNode> nodeValueMap) {
+            TreeNode node = nodeValueMap.get(nodeVal);
+            Long leftSubtree = 1L;
+            Long rightSubtree = 1L;
+            Long parentSubtree = 1L;
+            if (node.left != null) {
+                if (nodeCountMap.get(node.left.val) > 0) {
+                    leftSubtree = nodeCountMap.get(node.left.val);
+                }
+            }
+            if (node.right != null) {
+                if (nodeCountMap.get(node.right.val) > 0) {
+                    rightSubtree = nodeCountMap.get(node.right.val);
+                }
+            }
+            if (nodeVal != 0) {
+                long diff = nodeCountMap.get(0) - nodeCountMap.get(nodeVal);
+                if (diff > 0) {
+                    parentSubtree = diff;
+                }
+            }
+            return leftSubtree * rightSubtree * parentSubtree;
+        }
+
+        private long postOrder(TreeNode root, Map<Integer, Long> map) {
+            if (root == null) {
+                return 0;
+            }
+            long leftCount = postOrder(root.left, map);
+            long rightCount = postOrder(root.right, map);
+            long sum = leftCount + rightCount + 1;
+            map.put(root.val, sum);
+            return sum;
+        }
+
+        private TreeNode buildBinaryTree(int[] parents, Map<Integer, TreeNode> map) {
+            map.put(0, new TreeNode(0));
+            for (int i = 1; i < parents.length; i++) {
+                TreeNode childNode = map.getOrDefault(i, new TreeNode(i));
+                TreeNode parentNode = map.getOrDefault(parents[i], new TreeNode(parents[i]));
+                if (parentNode.left == null) {
+                    parentNode.left = childNode;
+                } else {
+                    parentNode.right = childNode;
+                }
+                map.put(parents[i], parentNode);
+                map.put(i, childNode);
+            }
+            return map.get(0);
+        }
+    }
+}

src/test/java/com/fishercoder/thirdthousand/_2049Test.java

@@ -0,0 +1,22 @@
+package com.fishercoder.thirdthousand;
+
+import com.fishercoder.solutions.thirdthousand._2049;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class _2049Test {
+    private static _2049.Solution1 solution1;
+
+    @BeforeEach
+    public void setup() {
+        solution1 = new _2049.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        assertEquals(3, solution1.countHighestScoreNodes(new int[]{-1, 2, 0, 2, 0}));
+    }
+
+}