Throne Inheritance - Practice Coding Problems

Throne Inheritance - Problem

👑 Throne Inheritance System

Imagine you're designing a digital system for a medieval kingdom to track the line of succession to the throne. The kingdom follows a specific inheritance order based on a depth-first traversal of the royal family tree.

How it works:

The king is always first in line
Children inherit before their aunts/uncles (depth-first)
Among siblings, older children inherit before younger ones
When someone dies, they're marked as deceased but stay in the family tree

Your task: Implement a ThroneInheritance class that can:

birth(parent, child) - Add a new child to the family
death(person) - Mark someone as deceased
getInheritanceOrder() - Return current inheritance order (excluding dead people)

Example: King → Alice → Alice's son Jack → Bob
If Alice dies, the order becomes: King → Jack → Bob

Input & Output

basic_inheritance.py — Python

$ Input: ThroneInheritance("king") birth("king", "andy") birth("king", "bob") birth("king", "catherine") birth("andy", "matthew") birth("bob", "alex") birth("bob", "asha") getInheritanceOrder()

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

💡 Note: DFS traversal: King → Andy → Andy's children (Matthew) → Bob → Bob's children (Alex, Asha) → Catherine

with_deaths.py — Python

$ Input: ThroneInheritance("king") birth("king", "andy") birth("king", "bob") birth("andy", "matthew") death("andy") getInheritanceOrder()

› Output: ["king", "matthew", "bob"]

💡 Note: Andy dies but stays in family tree. Matthew (Andy's son) inherits Andy's position. Order: King → Matthew → Bob

complex_family.py — Python

$ Input: ThroneInheritance("king") birth("king", "alice") birth("king", "bob") birth("alice", "jack") birth("alice", "jill") birth("bob", "charlie") death("alice") death("bob") getInheritanceOrder()

› Output: ["king", "jack", "jill", "charlie"]

💡 Note: Both Alice and Bob die, but their children inherit their positions in the family tree structure

Visualization

Tap to expand

Children Map:king → [Alice, Bob]Alice → [Jack]Bob → []💀 Dead Set{Alice}Skip in traversal👑 Result[King, Jack, Bob]DFS orderSkip AliceVisit order

Understanding the Visualization

Build Family Tree

Each birth adds a child to their parent's children list

Track Deaths

Dead people stay in tree but are marked in a separate set

DFS Traversal

Visit king first, then each child's subtree completely before siblings

Key Takeaway

🎯 Key Insight: Throne inheritance is just a DFS traversal of the family tree, where we maintain parent-child relationships efficiently using a hash map and skip deceased members during traversal.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each getInheritanceOrder takes O(n) time to visit each person once via DFS

✓ Linear Growth

Space Complexity

O(n)

Space for children hash map and dead set, both proportional to number of people

⚡ Linearithmic Space

Constraints

1 ≤ kingName.length, parentName.length, childName.length, name.length ≤ 15
kingName, parentName, childName, and name consist of lowercase English letters only
All arguments childName and kingName are distinct
All name arguments of death will be passed to either the constructor or as childName to birth first
At most 10⁵ calls will be made to birth and death
At most 10⁴ calls will be made to getInheritanceOrder

Asked in

⊞ Microsoft 15 a Amazon 12 G Google 8 f Meta 5

The optimal solution uses a hash map to maintain the family tree structure and a set for tracking deceased members. The key insight is that inheritance order follows DFS traversal of the family tree, making it efficient to query in O(n) time without rebuilding the tree structure.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Rebuild Tree Each Time)	O(n²)	O(n)	Rebuild entire family relationships and traverse from scratch each time
Optimized Tree Structure (Optimal)	O(n)	O(n)	Maintain tree structure with hash map for O(1) lookups and efficient DFS

Brute Force (Rebuild Tree Each Time) — Algorithm Steps

Store all births as (parent, child) pairs in a list
Store all deaths in a separate set
For getInheritanceOrder: rebuild tree from pairs
Perform DFS starting from king, skipping dead people

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Relationships

Keep all (parent,child) pairs in a list

Rebuild Tree

For each query, rebuild tree structure

DFS Traversal

Traverse tree depth-first, skip dead people

Code -

solution.c — C

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

#define MAX_PEOPLE 1000
#define MAX_NAME_LEN 50

typedef struct {
    char king[MAX_NAME_LEN];
    char relationships[MAX_PEOPLE][2][MAX_NAME_LEN];
    int relationCount;
    char dead[MAX_PEOPLE][MAX_NAME_LEN];
    int deadCount;
} ThroneInheritance;

ThroneInheritance* throneInheritanceCreate(char* kingName) {
    ThroneInheritance* obj = malloc(sizeof(ThroneInheritance));
    strcpy(obj->king, kingName);
    obj->relationCount = 0;
    obj->deadCount = 0;
    return obj;
}

void throneInheritanceBirth(ThroneInheritance* obj, char* parentName, char* childName) {
    strcpy(obj->relationships[obj->relationCount][0], parentName);
    strcpy(obj->relationships[obj->relationCount][1], childName);
    obj->relationCount++;
}

void throneInheritanceDeath(ThroneInheritance* obj, char* name) {
    strcpy(obj->dead[obj->deadCount], name);
    obj->deadCount++;
}

int isDead(ThroneInheritance* obj, char* name) {
    for (int i = 0; i < obj->deadCount; i++) {
        if (strcmp(obj->dead[i], name) == 0) return 1;
    }
    return 0;
}

void dfs(ThroneInheritance* obj, char* person, char result[][MAX_NAME_LEN], int* resultSize) {
    if (!isDead(obj, person)) {
        strcpy(result[*resultSize], person);
        (*resultSize)++;
    }
    
    for (int i = 0; i < obj->relationCount; i++) {
        if (strcmp(obj->relationships[i][0], person) == 0) {
            dfs(obj, obj->relationships[i][1], result, resultSize);
        }
    }
}

char** throneInheritanceGetInheritanceOrder(ThroneInheritance* obj, int* returnSize) {
    static char result[MAX_PEOPLE][MAX_NAME_LEN];
    *returnSize = 0;
    dfs(obj, obj->king, result, returnSize);
    
    char** retArray = malloc(sizeof(char*) * (*returnSize));
    for (int i = 0; i < *returnSize; i++) {
        retArray[i] = malloc(sizeof(char) * MAX_NAME_LEN);
        strcpy(retArray[i], result[i]);
    }
    return retArray;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each getInheritanceOrder call takes O(n) to rebuild tree, and if called n times, total is O(n²)

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing all relationships and dead people set

⚡ Linearithmic Space

Constraints

1 ≤ kingName.length, parentName.length, childName.length, name.length ≤ 15
kingName, parentName, childName, and name consist of lowercase English letters only
All arguments childName and kingName are distinct
All name arguments of death will be passed to either the constructor or as childName to birth first
At most 10⁵ calls will be made to birth and death
At most 10⁴ calls will be made to getInheritanceOrder

42.3K Views

Medium Frequency

~25 min Avg. Time

1.5K 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

👑 Throne Inheritance System

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Rebuild Tree Each Time) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler