Maximum Good People Based on Statements - Practice Coding Problems

Maximum Good People Based on Statements - Problem

Imagine you're a detective investigating a group of suspects where some always tell the truth (good people) and others might lie (bad people). Your job is to determine the maximum number of people who could be truthful based on their statements about each other.

You are given an n x n matrix statements where:

statements[i][j] = 0: Person i claims person j is bad
statements[i][j] = 1: Person i claims person j is good
statements[i][j] = 2: Person i makes no statement about person j

Key Rule: Good people always tell the truth, while bad people can either lie or tell the truth. No one makes statements about themselves (statements[i][i] = 2).

Goal: Find the maximum number of people who can simultaneously be good without creating any contradictions in their statements.

Input & Output

example_1.py — Basic Case

$ Input: statements = [[2,1,2],[1,2,2],[2,0,2]]

› Output: 2

💡 Note: Person 0 says person 1 is good, and person 1 says person 0 is good. They could both be telling the truth. Person 1 also says person 2 is bad, which is consistent if person 2 is indeed bad. Maximum good people: persons 0 and 1.

example_2.py — All Good Impossible

$ Input: statements = [[2,0],[0,2]]

› Output: 1

💡 Note: Person 0 says person 1 is bad, and person 1 says person 0 is bad. They can't both be good (good people tell the truth). At most one can be good, so the answer is 1.

example_3.py — Single Person

$ Input: statements = [[2]]

› Output: 1

💡 Note: With only one person who makes no statements about others, they can be good. The maximum is 1.

Constraints

n == statements.length == statements[i].length
2 ≤ n ≤ 15
statements[i][j] is 0, 1, or 2
statements[i][i] == 2 (no self-statements)
At least one person can always be considered good

Visualization

Tap to expand

Understanding the Visualization

List All Possibilities

Create every possible combination of who could be truthful vs. untruthful

Test Each Scenario

For each possibility, check if all truthful people's statements are consistent

Count Valid Witnesses

When statements align, count how many people are truthful in that scenario

Find Maximum

Return the largest number of truthful people from any valid scenario

Key Takeaway

🎯 Key Insight: Since n ≤ 15, we can efficiently check all 2^n possible truth assignments using bitmasks. Each valid assignment where all truthful people's statements are consistent gives us a candidate answer, and we return the maximum count found.

Asked in

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

This problem requires checking all possible assignments of good/bad people to find the maximum valid good people count. The optimal approach uses bit manipulation to enumerate all 2^n possible assignments efficiently. For each bitmask representing an assignment, we validate that all good people's statements are consistent with reality. The constraint n ≤ 15 makes this exponential approach feasible, and bit operations provide clean implementation.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking (Try All Combinations)	O(2^n * n^2)	O(n)	Recursively try every possible assignment of good/bad for each person
Bit Manipulation Enumeration (Optimal)	O(2^n * n^2)	O(1)	Use bitmasks to efficiently represent and check all possible combinations of good people

Backtracking (Try All Combinations) — Algorithm Steps

Start with person 0 and recursively try assigning them as good or bad
For each assignment, recursively process the next person
When all people are assigned, validate the current assignment for consistency
Check that every good person's statements align with the current assignment
Track and return the maximum number of good people from all valid assignments

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at person 0

Begin recursive exploration by deciding if person 0 is good or bad

Branch on each person

For each person, create two branches: one for good, one for bad

Validate complete assignments

When all people are assigned, check if good people's statements are consistent

Track maximum

Keep track of the highest number of good people in any valid assignment

Code -

solution.c — C

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

int maxGood = 0;

int isValid(int** statements, int* assignment, int n) {
    for (int i = 0; i < n; i++) {
        if (assignment[i] == 1) { // If person i is good
            for (int j = 0; j < n; j++) {
                if (i != j && statements[i][j] != 2) {
                    // Good person's statement must be true
                    if (statements[i][j] != assignment[j]) {
                        return 0;
                    }
                }
            }
        }
    }
    return 1;
}

void backtrack(int index, int** statements, int* assignment, int n, int goodCount) {
    if (index == n) {
        if (isValid(statements, assignment, n)) {
            if (goodCount > maxGood) {
                maxGood = goodCount;
            }
        }
        return;
    }
    
    // Try assigning person as bad (0)
    assignment[index] = 0;
    backtrack(index + 1, statements, assignment, n, goodCount);
    
    // Try assigning person as good (1)
    assignment[index] = 1;
    backtrack(index + 1, statements, assignment, n, goodCount + 1);
}

int maximumGood(int** statements, int n) {
    maxGood = 0;
    int* assignment = (int*)calloc(n, sizeof(int));
    backtrack(0, statements, assignment, n, 0);
    free(assignment);
    return maxGood;
}

int main() {
    // Example usage
    int n = 3;
    int** statements = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        statements[i] = (int*)malloc(n * sizeof(int));
    }
    
    // Initialize with example data
    int data[3][3] = {{2,1,2},{1,2,2},{2,0,2}};
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            statements[i][j] = data[i][j];
        }
    }
    
    printf("%d\n", maximumGood(statements, n));
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(statements[i]);
    }
    free(statements);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n^2)

2^n possible assignments, each taking O(n^2) time to validate all statements

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth of n plus assignment array storage

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Backtracking (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler