Add solution #1600

Author: JoshCrozier

README.md

@@ -1,4 +1,4 @@
-# 1,410 LeetCode solutions in JavaScript
+# 1,411 LeetCode solutions in JavaScript
 
 [https://leetcodejavascript.com](https://leetcodejavascript.com)
 
@@ -1235,6 +1235,7 @@
 1595|[Minimum Cost to Connect Two Groups of Points](./solutions/1595-minimum-cost-to-connect-two-groups-of-points.js)|Hard|
 1598|[Crawler Log Folder](./solutions/1598-crawler-log-folder.js)|Easy|
 1599|[Maximum Profit of Operating a Centennial Wheel](./solutions/1599-maximum-profit-of-operating-a-centennial-wheel.js)|Medium|
+1600|[Throne Inheritance](./solutions/1600-throne-inheritance.js)|Medium|
 1657|[Determine if Two Strings Are Close](./solutions/1657-determine-if-two-strings-are-close.js)|Medium|
 1668|[Maximum Repeating Substring](./solutions/1668-maximum-repeating-substring.js)|Easy|
 1669|[Merge In Between Linked Lists](./solutions/1669-merge-in-between-linked-lists.js)|Medium|

solutions/1600-throne-inheritance.js

@@ -0,0 +1,86 @@
+/**
+ * 1600. Throne Inheritance
+ * https://leetcode.com/problems/throne-inheritance/
+ * Difficulty: Medium
+ *
+ * A kingdom consists of a king, his children, his grandchildren, and so on. Every once in a while,
+ * someone in the family dies or a child is born.
+ *
+ * The kingdom has a well-defined order of inheritance that consists of the king as the first
+ * member. Let's define the recursive function Successor(x, curOrder), which given a person x and
+ * the inheritance order so far, returns who should be the next person after x in the order of
+ * inheritance.
+ *
+ * For example, assume we have a kingdom that consists of the king, his children Alice and Bob
+ * (Alice is older than Bob), and finally Alice's son Jack.
+ *
+ * 1. In the beginning, curOrder will be ["king"].
+ * 2. Calling Successor(king, curOrder) will return Alice, so we append to curOrder to
+ *    get ["king", "Alice"].
+ * 3. Calling Successor(Alice, curOrder) will return Jack, so we append to curOrder to
+ *    get ["king", "Alice", "Jack"].
+ * 4. Calling Successor(Jack, curOrder) will return Bob, so we append to curOrder to
+ *    get ["king", "Alice", "Jack", "Bob"].
+ * 5. Calling Successor(Bob, curOrder) will return null. Thus the order of inheritance
+ *    will be ["king", "Alice", "Jack", "Bob"].
+ *
+ * Using the above function, we can always obtain a unique order of inheritance.
+ *
+ * Implement the ThroneInheritance class:
+ * - ThroneInheritance(string kingName) Initializes an object of the ThroneInheritance class.
+ *   The name of the king is given as part of the constructor.
+ * - void birth(string parentName, string childName) Indicates that parentName gave birth
+ *   to childName.
+ * - void death(string name) Indicates the death of name. The death of the person doesn't
+ *   affect the Successor function nor the current inheritance order. You can treat it as
+ *   just marking the person as dead.
+ * - string[] getInheritanceOrder() Returns a list representing the current order of inheritance
+ *   excluding dead people.
+ */
+
+/**
+ * @param {string} kingName
+ */
+var ThroneInheritance = function(kingName) {
+  this.king = kingName;
+  this.familyTree = new Map();
+  this.deceased = new Set();
+};
+
+/**
+ * @param {string} parentName
+ * @param {string} childName
+ * @return {void}
+ */
+ThroneInheritance.prototype.birth = function(parentName, childName) {
+  if (!this.familyTree.has(parentName)) {
+    this.familyTree.set(parentName, []);
+  }
+  this.familyTree.get(parentName).push(childName);
+};
+
+/**
+ * @param {string} name
+ * @return {void}
+ */
+ThroneInheritance.prototype.death = function(name) {
+  this.deceased.add(name);
+};
+
+/**
+ * @return {string[]}
+ */
+ThroneInheritance.prototype.getInheritanceOrder = function() {
+  const result = [];
+  const traverse = (person) => {
+    if (!this.deceased.has(person)) {
+      result.push(person);
+    }
+    const children = this.familyTree.get(person) || [];
+    for (const child of children) {
+      traverse(child);
+    }
+  };
+  traverse(this.king);
+  return result;
+};