Minimum Number of People to Teach - Practice Coding Problems

Minimum Number of People to Teach - Problem

Minimum Number of People to Teach

Imagine a social network where m users are connected through friendships, but they speak different languages! Two users can only communicate if they share at least one common language.

You are given:
• n languages numbered from 1 to n
• languages[i] - a list of languages that user i knows
• friendships - pairs of users who are friends

Your mission: Choose ONE language and teach it to the minimum number of people so that every pair of friends can communicate with each other.

Note: Friendships are not transitive - if A is friends with B, and B is friends with C, it doesn't mean A and C are friends.

Input & Output

example_1.py — Basic Communication Problem

$ Input: n = 2, languages = [[1],[2],[1,2]], friendships = [[1,2],[1,3],[2,3]]

› Output: 1

💡 Note: User 1 and User 2 cannot communicate (User 1 speaks [1], User 2 speaks [2]). We can teach Language 1 to User 2 or Language 2 to User 1. Either way, we need to teach 1 person.

example_2.py — All Can Communicate

$ Input: n = 3, languages = [[2],[1,3],[1,2]], friendships = [[1,2],[2,3]]

› Output: 0

💡 Note: User 1-2 friendship: User 1 speaks [2], User 2 speaks [1,3] - no common language. But User 2-3 friendship: User 2 speaks [1,3], User 3 speaks [1,2] - they share language 1. Wait, let me recalculate... Actually User 1 and User 2 have no common language, so we need to teach someone.

example_3.py — Multiple Disconnected Groups

$ Input: n = 3, languages = [[1,2],[1,3],[2,3],[1]], friendships = [[1,2],[2,3],[3,4]]

› Output: 1

💡 Note: All adjacent pairs can communicate except some specific pair. We need to identify the most efficient language to teach to connect all friend pairs.

Constraints

2 ≤ n ≤ 500 (number of languages)
1 ≤ m ≤ 500 (number of users)
1 ≤ friendships.length ≤ 500
1 ≤ languages[i].length ≤ n
All values in languages[i] are distinct and between 1 and n
friendships[i].length == 2
1 ≤ u_i, v_i ≤ m
u_i ≠ v_i

Visualization

Tap to expand

Identify Problematic Pairs: U1-U2 (no common lang), U2-U5 (no common lang)2. Focus on Problem Users: U1, U2, U5 (ignore U3, U4 - not in blocked pairs)3. Language Options: • Teach Lang 1: U2, U5 need it → 2 people • Teach Lang 2: U1, U5 need it → 2 people • Teach Lang 3: U1, U2 need it → 2 peopleMinimum: 2 people need to learn any language

Understanding the Visualization

Map the Network

Identify all friendships and their language barriers

Find Problems

Locate friend pairs who cannot communicate (no shared language)

Focus Resources

Only consider people involved in problematic friendships

Optimize Teaching

Choose the language that minimizes total people needing training

Key Takeaway

🎯 Key Insight: Only people involved in communication-blocked friendships matter. Find them first, then choose the language requiring minimum teachings among this focused group.

Asked in

f Meta 8 G Google 6 ⊞ Microsoft 4 a Amazon 3

The key insight is to focus only on problematic people - those involved in friendships with communication barriers. First identify all friend pairs that cannot communicate, then for each possible language, count how many of these problematic people would need to learn it. The greedy approach of teaching the language that requires minimum teachings gives the optimal solution.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try Every Language)	O(n * m * f)	O(m + f)	Try teaching each language to all necessary people and pick the minimum
Optimal Greedy with Hash Maps	O(n * (f + \|P\|))	O(m + f)	Find problematic pairs first, then greedily pick the best language

Brute Force (Try Every Language) — Algorithm Steps

Find all friend pairs who cannot currently communicate
For each language from 1 to n, count how many people need to learn it
For each problematic pair, at least one person must learn the chosen language
Return the minimum count across all languages

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Problematic Pairs

Identify friend pairs with no common language

Try Each Language

For each language, count how many people need to learn it

Pick Minimum

Return the language requiring minimum teachings

Code -

solution.c — C

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

#define MAX_USERS 500
#define MAX_LANGS 500

int minimumTeachings(int n, int languages[][MAX_LANGS], int langCounts[], int friendships[][2], int m, int f) {
    // Create language sets as boolean arrays
    int langSets[MAX_USERS][MAX_LANGS + 1];
    memset(langSets, 0, sizeof(langSets));
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < langCounts[i]; j++) {
            langSets[i][languages[i][j]] = 1;
        }
    }
    
    // Find problematic pairs
    int problematicPairs[f][2];
    int problematicCount = 0;
    
    for (int i = 0; i < f; i++) {
        int u = friendships[i][0] - 1, v = friendships[i][1] - 1;
        int hasCommon = 0;
        
        for (int lang = 1; lang <= n; lang++) {
            if (langSets[u][lang] && langSets[v][lang]) {
                hasCommon = 1;
                break;
            }
        }
        
        if (!hasCommon) {
            problematicPairs[problematicCount][0] = u;
            problematicPairs[problematicCount][1] = v;
            problematicCount++;
        }
    }
    
    if (problematicCount == 0) return 0;
    
    int minTeachings = MAX_USERS;
    
    for (int lang = 1; lang <= n; lang++) {
        int peopleToTeach[MAX_USERS] = {0};
        int teachCount = 0;
        
        for (int i = 0; i < problematicCount; i++) {
            int u = problematicPairs[i][0], v = problematicPairs[i][1];
            int uKnows = langSets[u][lang];
            int vKnows = langSets[v][lang];
            
            if (!uKnows && !vKnows) {
                if (!peopleToTeach[u]) {
                    peopleToTeach[u] = 1;
                    teachCount++;
                }
            } else if (!uKnows) {
                if (!peopleToTeach[u]) {
                    peopleToTeach[u] = 1;
                    teachCount++;
                }
            } else if (!vKnows) {
                if (!peopleToTeach[v]) {
                    peopleToTeach[v] = 1;
                    teachCount++;
                }
            }
        }
        
        if (teachCount < minTeachings) {
            minTeachings = teachCount;
        }
    }
    
    return minTeachings;
}

int main() {
    // Example usage
    int languages[3][MAX_LANGS] = {{1}, {2}, {1, 2}};
    int langCounts[] = {1, 1, 2};
    int friendships[][2] = {{1, 2}, {1, 3}, {2, 3}};
    printf("%d\n", minimumTeachings(2, languages, langCounts, friendships, 3, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m * f)

n languages × m users × f friendships to check

✓ Linear Growth

Space Complexity

O(m + f)

Storage for user languages and friendship data

✓ Linear Space

23.6K Views

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try Every Language) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler