Find Circular Gift Exchange Chains - Practice Coding Problems

Find Circular Gift Exchange Chains - Problem

Database Hard

Imagine it's the holiday season at your company, and employees are participating in a Secret Santa gift exchange! 🎁

You're given a table SecretSanta that records all the gift exchanges between employees. Your task is to find all the circular chains of gift exchanges and calculate their total value.

A circular chain is a special pattern where:

Each employee gives a gift to exactly one other employee
Each employee receives a gift from exactly one other employee
The exchanges form a continuous loop (e.g., A → B → C → A)

For each circular chain found, you need to return:

chain_id: A unique identifier for the chain
chain_length: Number of employees in the chain
total_gift_value: Sum of all gift values in the chain

Results should be ordered by chain length and total gift value in descending order.

Input & Output

example_1.py — Basic Circular Chains

$ Input: SecretSanta = [[1,2,20], [2,3,30], [3,1,40], [4,5,25], [5,4,35]]

› Output: [[1,3,90], [2,2,60]]

💡 Note: Two circular chains found: Chain 1 (1→2→3→1) with length 3 and total value $90, Chain 2 (4→5→4) with length 2 and total value $60. Ordered by chain length desc, then total value desc.

example_2.py — Single Large Chain

$ Input: SecretSanta = [[1,2,10], [2,3,15], [3,4,20], [4,1,25]]

› Output: [[1,4,70]]

💡 Note: One circular chain of length 4: employees 1→2→3→4→1. Total gift value = 10+15+20+25 = $70.

example_3.py — No Circular Chains

$ Input: SecretSanta = [[1,2,100], [3,4,200], [5,6,300]]

› Output: []

💡 Note: No circular chains exist - each exchange is a one-way gift with no return path, so no employee both gives and receives in a continuous loop.

Constraints

1 ≤ number of exchanges ≤ 1000
1 ≤ giver_id, receiver_id ≤ 1000
1 ≤ gift_value ≤ 10⁴
Each employee can give at most one gift
Circular chains must have at least 1 participant

Visualization

Tap to expand

Understanding the Visualization

Model as Graph

Each employee is a node, each gift exchange is a directed edge

Detect Cycles

Use DFS to find closed loops where gift flow returns to starting employee

Calculate Metrics

For each cycle, count participants and sum all gift values

Sort Results

Order chains by length (descending), then by total value (descending)

Key Takeaway

🎯 Key Insight: Transform the gift exchange problem into cycle detection in a directed graph. Each employee has exactly one outgoing edge, making DFS cycle detection optimal with O(V + E) complexity.

Asked in

f Meta 45 G Google 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses graph theory and DFS cycle detection to efficiently find circular gift exchange chains. Model exchanges as a directed graph where each employee has exactly one outgoing edge. Use Depth-First Search to detect cycles in O(V + E) time, processing each employee exactly once. This approach handles complex scenarios like multiple chains, self-loops, and dead ends while maintaining optimal performance.

Common Approaches

Approach	Time	Space	Notes
✓ Graph Traversal with DFS (Optimal)	O(V + E)	O(V + E)	Use DFS to efficiently detect cycles in the gift exchange graph
Brute Force (Check All Chains)	O(n²)	O(n)	For each employee, follow their gift chain until we find a cycle or dead end

Graph Traversal with DFS (Optimal) — Algorithm Steps

Build adjacency list from gift exchanges
For each unvisited employee, start DFS
Track path during DFS to detect back edges (cycles)
When cycle found, calculate chain length and total value
Mark all nodes in found cycles as processed
Sort results by chain length and total value

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from gift exchanges - each employee points to their receiver

DFS Traversal

Start DFS from unvisited employee, tracking current path

Cycle Detection

When we revisit a node in current path, we've found a cycle

Calculate Metrics

Extract cycle portion and sum gift values

Mark Visited

Mark all nodes in path as processed to avoid reprocessing

Code -

solution.c — C

// Optimal C solution using arrays and DFS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_EMPLOYEES 1000
#define MAX_CHAINS 100

typedef struct {
    int receiver;
    int value;
} Exchange;

typedef struct {
    int id;
    int length;
    int totalValue;
} Chain;

int compareChains(const void* a, const void* b) {
    Chain* chainA = (Chain*)a;
    Chain* chainB = (Chain*)b;
    if (chainB->length != chainA->length) {
        return chainB->length - chainA->length;
    }
    return chainB->totalValue - chainA->totalValue;
}

Chain detectCycle(Exchange graph[], int globalVisited[], int start) {
    int pathVisited[MAX_EMPLOYEES] = {0};
    int path[MAX_EMPLOYEES];
    int pathLength = 0;
    int current = start;
    
    while (current != -1) {
        // Already processed
        if (globalVisited[current]) {
            return (Chain){0, 0, 0};
        }
        
        // Cycle detected
        if (pathVisited[current]) {
            // Find cycle start
            int cycleStart = -1;
            for (int i = 0; i < pathLength; i++) {
                if (path[i] == current) {
                    cycleStart = i;
                    break;
                }
            }
            
            if (cycleStart == -1) return (Chain){0, 0, 0};
            
            // Calculate cycle metrics
            int cycleLength = pathLength - cycleStart;
            int totalValue = 0;
            for (int i = cycleStart; i < pathLength; i++) {
                totalValue += graph[path[i]].value;
            }
            
            // Mark path as visited
            for (int i = 0; i < pathLength; i++) {
                globalVisited[path[i]] = 1;
            }
            
            return (Chain){0, cycleLength, totalValue};
        }
        
        pathVisited[current] = 1;
        path[pathLength++] = current;
        
        if (graph[current].receiver == -1) break;
        
        current = graph[current].receiver;
    }
    
    // Mark dead-end path as visited
    for (int i = 0; i < pathLength; i++) {
        globalVisited[path[i]] = 1;
    }
    
    return (Chain){0, 0, 0};
}

int findCircularChains(int exchanges[][3], int exchangeCount, Chain* chains) {
    Exchange graph[MAX_EMPLOYEES];
    int globalVisited[MAX_EMPLOYEES] = {0};
    int chainCount = 0;
    
    // Initialize graph
    for (int i = 0; i < MAX_EMPLOYEES; i++) {
        graph[i].receiver = -1;
        graph[i].value = 0;
    }
    
    // Build graph - O(E)
    for (int i = 0; i < exchangeCount; i++) {
        int giver = exchanges[i][0];
        graph[giver].receiver = exchanges[i][1];
        graph[giver].value = exchanges[i][2];
    }
    
    // Find cycles - O(V + E)
    for (int i = 0; i < exchangeCount; i++) {
        int giver = exchanges[i][0];
        if (!globalVisited[giver]) {
            Chain cycle = detectCycle(graph, globalVisited, giver);
            if (cycle.length > 0) {
                chains[chainCount++] = cycle;
            }
        }
    }
    
    // Sort chains - O(C log C)
    qsort(chains, chainCount, sizeof(Chain), compareChains);
    
    // Assign IDs
    for (int i = 0; i < chainCount; i++) {
        chains[i].id = i + 1;
    }
    
    return chainCount;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Where V is number of employees and E is number of exchanges. Each node and edge visited once.

✓ Linear Growth

Space Complexity

O(V + E)

Space for adjacency list, visited tracking, and recursion stack

✓ Linear Space

28.4K Views

Medium-High 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

Graph Traversal with DFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler