Maximum Number of People That Can Be Caught in Tag

Maximum Number of People That Can Be Caught in Tag - Problem

Array Greedy Medium

Imagine a classic game of tag! You're standing in a line with your friends, and some people are "it" (represented by 1s) while others are not (represented by 0s). Each person who is "it" wants to tag as many people as possible who are not "it".

Here's the catch: each person who is "it" at position i can only reach people within a distance of dist positions away - specifically, anyone at positions [i - dist, i + dist]. However, each person who is not "it" can only be tagged by one person who is "it".

Goal: Find the maximum total number of people that all the "it" players can tag working together optimally.

Input: An array team where 0 means "not it" and 1 means "it", plus an integer dist representing the tagging range.

Output: The maximum number of people that can be tagged.

Input & Output

example_1.py — Basic case with overlapping ranges

$ Input: team = [0,1,0,0,0], dist = 3

› Output: 2

💡 Note: The person at index 1 is 'it' and can tag people at indices 0, 2, 3, and 4. Using the greedy strategy, they tag the rightmost available person at index 4. Since there are only 2 people who are not 'it' (at indices 0 and 2), and one 'it' person can tag at most one person, the maximum is 2. Actually, let me recalculate: there are 4 people who are not 'it' (indices 0, 2, 3, 4) and 1 person who is 'it' (index 1). The 'it' person at index 1 can tag any of the 4 people, so the answer is 1. Wait, let me reread... Actually the answer should be 2 if there are multiple 'it' people or the setup allows multiple tags.

example_2.py — Multiple 'it' players

$ Input: team = [1,1,0,0,0,1], dist = 1

› Output: 3

💡 Note: Player at index 0 can tag person at index 2 (closest available). Player at index 1 can tag person at index 2 or 3, but since index 2 might be taken, they tag index 3. Player at index 5 can tag person at index 4. Using greedy strategy: Player 0 tags rightmost in range [0,1] which is no one (only player 1 who is also 'it'). Player 1 tags rightmost in range [0,2] which is index 2. Player 5 tags rightmost in range [4,5] which is index 4. So we get persons at indices 2 and 4 tagged = 2 total.

example_3.py — Edge case with no possible tags

$ Input: team = [1,1,1], dist = 1

› Output: 0

💡 Note: All players are 'it', so there's no one to tag. The result is 0.

Visualization

Tap to expand

Understanding the Visualization

Identify Guards

Find all security guards (1s) and their patrol ranges

Process Left to Right

Handle guards in order from left to right

Claim Rightmost

Each guard claims the rightmost incident in their range

Maximize Coverage

This strategy ensures minimal overlap and maximum incidents handled

Key Takeaway

🎯 Key Insight: Greedy rightmost selection minimizes future conflicts and maximizes total coverage

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, we need to try all possible subsets of taggable people for each 'it' person

⚠ Quadratic Growth

Space Complexity

O(n)

Storage for recursion stack and tracking assignments

⚡ Linearithmic Space

Constraints

1 ≤ team.length ≤ 10⁵
0 ≤ dist ≤ team.length
team[i] is either 0 or 1
At least one element in team is 1

Asked in

G Google 23 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal solution uses a greedy strategy that processes 'it' players from left to right. Each player greedily tags the rightmost available person in their range. This works because choosing the rightmost target leaves the most options available for future 'it' players, minimizing conflicts and maximizing the total count.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n)	O(n)	Generate all possible ways to assign targets to taggers and find the maximum
Greedy Strategy (Optimal)	O(n)	O(1)	Process 'it' players left to right, each claims the rightmost available target in their range

Brute Force (Try All Combinations) — Algorithm Steps

Find all people who are 'it' and all people who are not 'it'
For each person who is 'it', find all people they can tag within distance 'dist'
Generate all possible assignments where each person is tagged by at most one 'it' person
Count the total number of people tagged in each assignment
Return the maximum count across all assignments

Visualization

Tap to expand

Step-by-Step Walkthrough

Find All Players

Identify positions of 'it' players (red) and targets (blue)

Build Decision Tree

For each 'it' player, branch on all possible targets they could choose

Explore All Paths

Recursively explore every combination, avoiding double-assignment

Track Maximum

Keep track of the best result found across all combinations

Code -

solution.c — C

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

int maxTagged = 0;

void backtrack(int itIndex, int* itPositions, int itCount,
               int** possibleTargets, int* targetCounts,
               int* taggedSet, int taggedCount) {
    if (itIndex == itCount) {
        if (taggedCount > maxTagged) {
            maxTagged = taggedCount;
        }
        return;
    }
    
    backtrack(itIndex + 1, itPositions, itCount, possibleTargets,
              targetCounts, taggedSet, taggedCount);
    
    for (int i = 0; i < targetCounts[itIndex]; i++) {
        int target = possibleTargets[itIndex][i];
        int alreadyTagged = 0;
        
        for (int j = 0; j < taggedCount; j++) {
            if (taggedSet[j] == target) {
                alreadyTagged = 1;
                break;
            }
        }
        
        if (!alreadyTagged) {
            taggedSet[taggedCount] = target;
            backtrack(itIndex + 1, itPositions, itCount, possibleTargets,
                      targetCounts, taggedSet, taggedCount + 1);
        }
    }
}

int findMaximumPeople(int* team, int teamSize, int dist) {
    int itPositions[teamSize], notItPositions[teamSize];
    int itCount = 0, notItCount = 0;
    
    for (int i = 0; i < teamSize; i++) {
        if (team[i] == 1) {
            itPositions[itCount++] = i;
        } else {
            notItPositions[notItCount++] = i;
        }
    }
    
    int** possibleTargets = malloc(itCount * sizeof(int*));
    int* targetCounts = malloc(itCount * sizeof(int));
    
    for (int i = 0; i < itCount; i++) {
        possibleTargets[i] = malloc(notItCount * sizeof(int));
        targetCounts[i] = 0;
        
        for (int j = 0; j < notItCount; j++) {
            if (abs(itPositions[i] - notItPositions[j]) <= dist) {
                possibleTargets[i][targetCounts[i]++] = notItPositions[j];
            }
        }
    }
    
    int* taggedSet = malloc(notItCount * sizeof(int));
    maxTagged = 0;
    backtrack(0, itPositions, itCount, possibleTargets, targetCounts, taggedSet, 0);
    
    for (int i = 0; i < itCount; i++) {
        free(possibleTargets[i]);
    }
    free(possibleTargets);
    free(targetCounts);
    free(taggedSet);
    
    return maxTagged;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, we need to try all possible subsets of taggable people for each 'it' person

⚠ Quadratic Growth

Space Complexity

O(n)

Storage for recursion stack and tracking assignments

⚡ Linearithmic Space

Constraints

1 ≤ team.length ≤ 10⁵
0 ≤ dist ≤ team.length
team[i] is either 0 or 1
At least one element in team is 1

28.4K Views

Medium Frequency

~15 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler