Throne Inheritance

Throne Inheritance - Problem

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.

Successor(x, curOrder):

if x has no children or all of x's children are in curOrder: if x is the king return null, else return Successor(x's parent, curOrder)
else return x's oldest child who's not in curOrder

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.

Input & Output

Example 1 — Basic Operations

$ Input: operations = [["ThroneInheritance", "king"], ["birth", "king", "andy"], ["birth", "king", "bob"], ["birth", "king", "catherine"], ["birth", "andy", "matthew"], ["birth", "bob", "alex"], ["birth", "bob", "asha"], ["getInheritanceOrder"], ["death", "bob"], ["getInheritanceOrder"]]

› Output: [null, null, null, null, null, null, null, ["king", "andy", "matthew", "bob", "alex", "asha", "catherine"], null, ["king", "andy", "matthew", "alex", "asha", "catherine"]]

💡 Note: Initially: king -> andy (matthew) -> bob (alex, asha) -> catherine. After bob dies, inheritance skips bob but includes his children.

Example 2 — King Dies

$ Input: operations = [["ThroneInheritance", "king"], ["birth", "king", "andy"], ["getInheritanceOrder"], ["death", "king"], ["getInheritanceOrder"]]

› Output: [null, null, ["king", "andy"], null, ["andy"]]

💡 Note: When king dies, andy becomes the first in inheritance order

Example 3 — Deep Family Tree

$ Input: operations = [["ThroneInheritance", "king"], ["birth", "king", "andy"], ["birth", "andy", "jack"], ["birth", "jack", "noah"], ["getInheritanceOrder"]]

› Output: [null, null, null, null, ["king", "andy", "jack", "noah"]]

💡 Note: Deep tree follows DFS: king -> andy -> jack -> noah

Constraints

1 ≤ kingName.length, parentName.length, childName.length, name.length ≤ 15
kingName, parentName, childName, and name consist of lowercase English letters only.
All arguments kingName, parentName, childName, and name are distinct.
All name arguments of death will be passed to either ThroneInheritance constructor or as childName to birth first.
For each call to birth(parentName, childName), it is guaranteed that parentName is alive.
At most 10⁵ calls will be made to birth and death.
At most 10 calls will be made to getInheritanceOrder.

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that inheritance order follows a depth-first search (DFS) traversal of the family tree. Best approach uses a tree structure with adjacency lists for children and a separate set to track deaths. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force Reconstruction

⏱️ Time: O(n) Space: O(n)

Store all birth and death records, then reconstruct the complete tree structure and perform DFS traversal every time getInheritanceOrder is called.

DFS Tree Traversal

⏱️ Time: O(n) Space: O(n)

Maintain a family tree using adjacency lists for children relationships. Track deaths separately and perform DFS traversal, skipping dead people when building the inheritance order.

Brute Force Reconstruction — Algorithm Steps

Store all operations in a list
For each getInheritanceOrder call, rebuild tree from scratch
Perform DFS to get inheritance order

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Operations

Keep track of all births and deaths

Rebuild Tree

Reconstruct family tree from operations

DFS Traversal

Perform depth-first search to get inheritance order

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_PEOPLE 1000
#define MAX_NAME_LEN 50
#define MAX_OPERATIONS 1000
#define MAX_LINE_LEN 100000

static char children[MAX_PEOPLE][MAX_PEOPLE][MAX_NAME_LEN];
static int childCount[MAX_PEOPLE];
static int dead[MAX_PEOPLE];
static char names[MAX_PEOPLE][MAX_NAME_LEN];
static int nameCount;
static char king[MAX_NAME_LEN];

int findPerson(const char* name) {
    for (int i = 0; i < nameCount; i++) {
        if (strcmp(names[i], name) == 0) {
            return i;
        }
    }
    strcpy(names[nameCount], name);
    return nameCount++;
}

void initThroneInheritance(const char* kingName) {
    strcpy(king, kingName);
    nameCount = 0;
    memset(childCount, 0, sizeof(childCount));
    memset(dead, 0, sizeof(dead));
    findPerson(kingName);
}

void birth(const char* parent, const char* child) {
    int parentId = findPerson(parent);
    int childId = findPerson(child);
    strcpy(children[parentId][childCount[parentId]++], child);
}

void death(const char* name) {
    int id = findPerson(name);
    dead[id] = 1;
}

void dfs(const char* person, char result[][MAX_NAME_LEN], int* count) {
    int id = findPerson(person);
    if (!dead[id]) {
        strcpy(result[(*count)++], person);
    }
    for (int i = 0; i < childCount[id]; i++) {
        dfs(children[id][i], result, count);
    }
}

int parseOperations(const char* line, char operations[][4][MAX_NAME_LEN]) {
    int opCount = 0;
    const char* p = line;
    
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']' && opCount < MAX_OPERATIONS) {
        while (*p == ' ' || *p == ',' || *p == '\n' || *p == '\t') p++;
        if (*p == '[') {
            p++;
            int argCount = 0;
            while (*p && *p != ']' && argCount < 4) {
                while (*p == ' ' || *p == ',' || *p == '\n' || *p == '\t') p++;
                if (*p == '"') {
                    p++;
                    const char* start = p;
                    while (*p && *p != '"') p++;
                    if (*p == '"') {
                        strncpy(operations[opCount][argCount], start, p - start);
                        operations[opCount][argCount][p - start] = '\0';
                        p++;
                        argCount++;
                    }
                }
            }
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
            opCount++;
        } else {
            p++;
        }
    }
    
    return opCount;
}

int main() {
    static char line[MAX_LINE_LEN];
    fgets(line, sizeof(line), stdin);
    
    static char operations[MAX_OPERATIONS][4][MAX_NAME_LEN];
    int opCount = parseOperations(line, operations);
    
    static char inheritanceResult[MAX_PEOPLE][MAX_NAME_LEN];
    int inheritanceCount;
    
    printf("[");
    
    for (int i = 0; i < opCount; i++) {
        if (i > 0) printf(",");
        
        if (strcmp(operations[i][0], "ThroneInheritance") == 0) {
            initThroneInheritance(operations[i][1]);
            printf("null");
        } else if (strcmp(operations[i][0], "birth") == 0) {
            birth(operations[i][1], operations[i][2]);
            printf("null");
        } else if (strcmp(operations[i][0], "death") == 0) {
            death(operations[i][1]);
            printf("null");
        } else if (strcmp(operations[i][0], "getInheritanceOrder") == 0) {
            inheritanceCount = 0;
            dfs(king, inheritanceResult, &inheritanceCount);
            printf("[");
            for (int j = 0; j < inheritanceCount; j++) {
                if (j > 0) printf(",");
                printf("\"%s\"", inheritanceResult[j]);
            }
            printf("]");
        }
    }
    
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each operation takes O(n) time due to tree reconstruction

✓ Linear Growth

Space Complexity

O(n)

Store all family members and their relationships

⚡ Linearithmic Space

31.5K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Reconstruction — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler