Loud and Rich - Practice Coding Problems

Loud and Rich - Problem

Imagine a social circle where wealth creates a hierarchy, but quietness is the most valued trait. You're given information about n people, each with different amounts of money and varying levels of quietness.

You have an array richer where richer[i] = [a, b] means person a has more money than person b. You also have an array quiet where quiet[i] represents how quiet person i is (lower values mean quieter).

Your task: For each person, find the quietest person among all people who have equal or more money than them. This could be themselves if they're the quietest in their wealth tier!

Example: If person 0 has $100, person 1 has $200, and person 2 has $150, and their quietness levels are [5, 2, 8], then for person 0, we need to find the quietest among {person 1, person 2} since both are richer. Person 1 with quietness 2 would be the answer.

Input & Output

example_1.py — Basic Hierarchy

$ Input: richer = [[1,0],[2,1],[3,1],[3,7],[4,3],[5,3],[6,3]], quiet = [3,2,5,4,6,1,7,0]

› Output: [5,5,2,5,4,5,6,7]

💡 Note: For person 0: People 1,2,3,4,5,6 are richer. Among them, person 5 has the lowest quiet value (1). For person 1: People 2,3,4,5,6 are richer. Person 5 is the quietest. And so on...

example_2.py — Simple Case

$ Input: richer = [[0,1],[1,2]], quiet = [5,3,1]

› Output: [0,1,2]

💡 Note: Person 2 has no one richer, so answer is themselves. Person 1 has person 0 richer (quiet=5) vs themselves (quiet=3), so answer is themselves. Person 0 has no one richer, so answer is themselves.

example_3.py — Single Person

$ Input: richer = [], quiet = [0]

› Output: [0]

💡 Note: Only one person exists, and no one is richer than anyone else. So the answer for person 0 is themselves.

Visualization

Tap to expand

Understanding the Visualization

Build Hierarchy

Create a graph where arrows point from poorer to richer people

DFS Exploration

For each person, explore all paths to richer people using DFS

Find Quietest

Among all reachable richer people (including self), select the quietest

Memoization

Cache results to avoid recalculating for overlapping subproblems

Key Takeaway

🎯 Key Insight: By modeling wealth as a directed graph and using DFS with memoization, we can efficiently find the quietest person in each person's wealth hierarchy without redundant calculations.

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Each person is processed at most once due to memoization, and each edge is traversed at most once

✓ Linear Growth

Space Complexity

O(n + m)

Space for adjacency list (m edges), memoization array (n), and recursion stack (up to n deep)

⚡ Linearithmic Space

Constraints

n == quiet.length
1 ≤ n ≤ 500
0 ≤ quiet[i] < n
All values of quiet are unique
0 ≤ richer.length ≤ n * (n - 1) / 2
0 ≤ a_i, b_i < n
a_i != b_i
All pairs (a_i, b_i) are unique
The observations in richer are all logically consistent

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Facebook 6

The optimal approach uses DFS with memoization to build a graph of wealth relationships and efficiently find the quietest person among all richer individuals. By caching results, we avoid redundant calculations and achieve O(n + m) time complexity where n is the number of people and m is the number of wealth relationships.

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Memoization (Optimal)	O(n + m)	O(n + m)	Use DFS with memoization to avoid recalculating results for the same person
Brute Force Graph Traversal	O(n * (n + m))	O(n + m)	For each person, use BFS/DFS to find all richer people and select the quietest

DFS with Memoization (Optimal) — Algorithm Steps

Build adjacency list where graph[i] contains all people richer than person i
Create memoization array initialized to -1
For each person, use DFS with memoization to find quietest richer person
In DFS: if already calculated, return cached result; otherwise calculate and cache

Visualization

Tap to expand

Step-by-Step Walkthrough

First DFS Call

Calculate and cache result for person 3

Subsequent Calls

Reuse cached result when person 3 is encountered again

Optimal Performance

Each person processed exactly once

Code -

solution.c — C

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

#define MAX_N 500

int graph[MAX_N][MAX_N];
int graphSize[MAX_N];
int memo[MAX_N];
int* globalQuiet;

int dfs(int person) {
    if (memo[person] != -1) {
        return memo[person];
    }
    
    int quietest = person;
    
    for (int i = 0; i < graphSize[person]; i++) {
        int richerPerson = graph[person][i];
        int candidate = dfs(richerPerson);
        if (globalQuiet[candidate] < globalQuiet[quietest]) {
            quietest = candidate;
        }
    }
    
    memo[person] = quietest;
    return quietest;
}

int* loudAndRich(int** richer, int richerSize, int* richerColSize, int* quiet, int quietSize, int* returnSize) {
    *returnSize = quietSize;
    int* result = (int*)malloc(quietSize * sizeof(int));
    globalQuiet = quiet;
    
    // Initialize
    for (int i = 0; i < quietSize; i++) {
        graphSize[i] = 0;
        memo[i] = -1;
    }
    
    // Build adjacency list
    for (int i = 0; i < richerSize; i++) {
        int a = richer[i][0];
        int b = richer[i][1];
        graph[b][graphSize[b]++] = a;
    }
    
    // Find result for each person
    for (int i = 0; i < quietSize; i++) {
        result[i] = dfs(i);
    }
    
    return result;
}

int main() {
    int richerData[][2] = {{1, 0}, {2, 1}, {3, 1}, {3, 7}, {4, 3}, {5, 3}, {6, 3}};
    int* richer[7];
    for (int i = 0; i < 7; i++) {
        richer[i] = richerData[i];
    }
    int richerColSize[] = {2, 2, 2, 2, 2, 2, 2};
    int quiet[] = {3, 2, 5, 4, 6, 1, 7, 0};
    int returnSize;
    
    int* result = loudAndRich(richer, 7, richerColSize, quiet, 8, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(", ");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Each person is processed at most once due to memoization, and each edge is traversed at most once

✓ Linear Growth

Space Complexity

O(n + m)

Space for adjacency list (m edges), memoization array (n), and recursion stack (up to n deep)

⚡ Linearithmic Space

Constraints

n == quiet.length
1 ≤ n ≤ 500
0 ≤ quiet[i] < n
All values of quiet are unique
0 ≤ richer.length ≤ n * (n - 1) / 2
0 ≤ a_i, b_i < n
a_i != b_i
All pairs (a_i, b_i) are unique
The observations in richer are all logically consistent

23.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

DFS with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler