Maximum Good People Based on Statements

Maximum Good People Based on Statements - Problem

There are two types of persons:

The good person: The person who always tells the truth.
The bad person: The person who might tell the truth and might lie.

You are given a 0-indexed 2D integer array statements of size n x n that represents the statements made by n people about each other. More specifically, statements[i][j] could be one of the following:

0 which represents a statement made by person i that person j is a bad person.
1 which represents a statement made by person i that person j is a good person.
2 represents that no statement is made by person i about person j.

Additionally, no person ever makes a statement about themselves. Formally, we have that statements[i][i] = 2 for all 0 <= i < n.

Return the maximum number of people who can be good based on the statements made by the n people.

Input & Output

Example 1 — Basic Consistency Check

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

› Output: 3

💡 Note: Person 0 says person 1 is good, person 1 says person 0 is good, person 2 makes no statements. All three can be good consistently since their statements don't contradict. Maximum good people = 3.

Example 2 — Contradictory Statements

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

› Output: 1

💡 Note: Person 0 says person 1 is bad, person 1 says person 0 is bad. They can't both be good (would contradict each other). Maximum good people = 1.

Example 3 — Single Person

$ Input: statements = [[2]]

› Output: 1

💡 Note: Only one person exists, no statements about others. That person can be good. Maximum good people = 1.

Constraints

n == statements.length == statements[i].length
2 ≤ n ≤ 15
statements[i][j] is either 0, 1, or 2
statements[i][i] == 2

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

The key insight is that good people always tell the truth, so we need to find the largest subset where all good people's statements are consistent with reality. The best approach uses bit manipulation enumeration to try all 2^n possible combinations of good/bad people and validate consistency. Time: O(n² × 2^n), Space: O(1).

Common Approaches

✓ Bit Manipulation

⏱️ Time: N/A Space: N/A

Backtracking with Pruning

⏱️ Time: O(2^n) Space: O(n)

Build combinations incrementally using backtracking. When we detect an inconsistency early, we prune that branch without exploring further combinations.

Try All Combinations

⏱️ Time: O(n × 2^n) Space: O(1)

Generate all possible combinations of who could be good people, then for each combination check if the statements made by good people are consistent with the assumed truth.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

void solution(int numArrows, int* aliceArrows, int* result) {
    int maxScore = 0;
    memset(result, 0, 12 * sizeof(int));
    
    // Try all possible subsets of sections to compete for
    for (int mask = 0; mask < (1 << 12); mask++) {
        int arrowsNeeded = 0;
        int score = 0;
        
        // Calculate arrows needed and score for this subset
        for (int i = 0; i < 12; i++) {
            if (mask & (1 << i)) {
                arrowsNeeded += aliceArrows[i] + 1;
                score += i;
            }
        }
        
        // If we can afford this combination
        if (arrowsNeeded <= numArrows) {
            if (score > maxScore) {
                maxScore = score;
                // Allocate arrows
                int bobArrows[12] = {0};
                for (int i = 0; i < 12; i++) {
                    if (mask & (1 << i)) {
                        bobArrows[i] = aliceArrows[i] + 1;
                    }
                }
                // Put remaining arrows in section 0
                bobArrows[0] += numArrows - arrowsNeeded;
                memcpy(result, bobArrows, 12 * sizeof(int));
            }
        }
    }
}

int main() {
    int numArrows;
    scanf("%d", &numArrows);
    
    int aliceArrows[12];
    char c;
    scanf(" %c", &c); // consume '['
    for (int i = 0; i < 12; i++) {
        scanf("%d", &aliceArrows[i]);
        if (i < 11) scanf("%c", &c); // consume ','
    }
    scanf("%c", &c); // consume ']'
    
    int result[12];
    solution(numArrows, aliceArrows, result);
    
    printf("[");
    for (int i = 0; i < 12; i++) {
        printf("%d", result[i]);
        if (i < 11) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~25 min Avg. Time

485 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