Count Unhappy Friends - Practice Coding Problems

Count Unhappy Friends - Problem

Array Simulation Medium

The Friend Pairing Dilemma

Imagine you're organizing a social event where n friends (where n is always even) need to be paired up for activities. Each friend has provided you with their preferences list - a ranked ordering of all other friends from most preferred to least preferred partner.

You've already created the pairs based on some criteria, but now you need to determine how many friends are unhappy with their pairing.

A friend x is considered unhappy if they are paired with y, but there exists another friend u (who is paired with v) such that:
• Friend x prefers u over their current partner y
• Friend u also prefers x over their current partner v

Goal: Count the total number of unhappy friends given their preferences and current pairings.

Input & Output

example_1.py — Basic Case

$ Input: n = 4, preferences = [[1, 2, 3], [3, 2, 0], [3, 1, 0], [1, 2, 0]], pairs = [[0, 1], [2, 3]]

› Output: 2

💡 Note: Friend 0 is paired with 1 but prefers 2, and friend 2 prefers 0 over 3. Similarly, friend 2 is paired with 3 but prefers 1, and friend 1 prefers 2 over 0. So both friends 0 and 2 are unhappy.

example_2.py — All Happy

$ Input: n = 2, preferences = [[1], [0]], pairs = [[0, 1]]

› Output: 0

💡 Note: Both friends are paired with their most preferred choice, so no one is unhappy.

example_3.py — Larger Group

$ Input: n = 6, preferences = [[1, 4, 3, 2, 5], [0, 3, 2, 4, 5], [3, 0, 1, 4, 5], [2, 1, 4, 0, 5], [1, 3, 2, 0, 5], [0, 1, 2, 3, 4]], pairs = [[0, 1], [2, 3], [4, 5]]

› Output: 4

💡 Note: Multiple friends have mutual preferences with others outside their current pairing, resulting in 4 unhappy friends.

Visualization

Tap to expand

Understanding the Visualization

Current Pairings

Start with the given friend pairs

Build Preference Maps

Convert preference lists to ranking maps for fast lookups

Check Each Friend

For each person, see if they prefer someone else who also prefers them

Count Unhappy Friends

Sum up all friends who have mutual preferences outside their current pairing

Key Takeaway

🎯 Key Insight: Build ranking maps first for O(1) preference comparisons, then check each friend's potential alternative pairings for mutual preferences.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n friends, we check n other friends, and each check requires O(n) preference list search

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

2 ≤ n ≤ 500
n is even
preferences.length == n
preferences[i].length == n - 1
0 ≤ preferences[i][j] ≤ n - 1
preferences[i] does not contain i
All values in preferences[i] are unique
pairs.length == n/2
pairs[i].length == 2
0 ≤ x_i, y_i ≤ n - 1
x_i != y_i
All pairs are unique

Asked in

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

The optimal approach uses two-pass hash table optimization. First, build ranking maps to convert preference lists into hash tables for O(1) preference lookups. Then check each friend's happiness by comparing rankings directly. This reduces time complexity from O(n³) to O(n²) while using O(n²) extra space for fast lookups.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n³)	O(1)	Check every friend against every other friend with nested loops
Two-Pass Hash Table (Optimized)	O(n²)	O(n²)	Build preference ranking maps first, then efficiently check happiness

Brute Force (Nested Loops) — Algorithm Steps

For each friend x paired with y
Check every other friend u paired with v
Search x's preference list to see if u is preferred over y
Search u's preference list to see if x is preferred over v
If both conditions are met, x is unhappy

Visualization

Tap to expand

Step-by-Step Walkthrough

Create pair mapping

Map each friend to their current partner

Check each friend

For friend x, find all friends they prefer over current partner

Mutual preference check

For each preferred friend u, check if u also prefers x over their current partner

Code -

solution.c — C

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

int unhappyFriends(int n, int** preferences, int* preferencesSize, int** pairs, int pairsSize, int* pairsColSize) {
    // Create pair mapping
    int* pairMap = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < pairsSize; i++) {
        pairMap[pairs[i][0]] = pairs[i][1];
        pairMap[pairs[i][1]] = pairs[i][0];
    }
    
    int unhappyCount = 0;
    
    // Check each friend
    for (int x = 0; x < n; x++) {
        int y = pairMap[x]; // x's current partner
        
        // Find y's position in x's preference list
        int yIndex = -1;
        for (int i = 0; i < preferencesSize[x]; i++) {
            if (preferences[x][i] == y) {
                yIndex = i;
                break;
            }
        }
        
        // Check all friends x prefers over y
        int isUnhappy = 0;
        for (int i = 0; i < yIndex && !isUnhappy; i++) {
            int u = preferences[x][i]; // friend x prefers over y
            int v = pairMap[u]; // u's current partner
            
            // Find positions in u's preference list
            int vIndex = -1, xIndex = -1;
            for (int j = 0; j < preferencesSize[u]; j++) {
                if (preferences[u][j] == v) vIndex = j;
                if (preferences[u][j] == x) xIndex = j;
            }
            
            // Check if u prefers x over v
            if (xIndex != -1 && xIndex < vIndex) {
                unhappyCount++;
                isUnhappy = 1;
            }
        }
    }
    
    free(pairMap);
    return unhappyCount;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n friends, we check n other friends, and each check requires O(n) preference list search

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

2 ≤ n ≤ 500
n is even
preferences.length == n
preferences[i].length == n - 1
0 ≤ preferences[i][j] ≤ n - 1
preferences[i] does not contain i
All values in preferences[i] are unique
pairs.length == n/2
pairs[i].length == 2
0 ≤ x_i, y_i ≤ n - 1
x_i != y_i
All pairs are unique

18.5K Views

Medium Frequency

~25 min Avg. Time

847 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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler