Maximum Enemy Forts That Can Be Captured - Practice Coding Problems

Maximum Enemy Forts That Can Be Captured - Problem

You are a strategic commander with control over multiple friendly forts scattered across a battlefield. Your mission is to maximize enemy fort captures through tactical army movements!

Given an array forts representing the battlefield:

1 = Your friendly fort 🏰
0 = Enemy fort 💀
-1 = Empty position 🏜️

Movement Rules:

Move your army from any friendly fort to any empty position
Your path must contain only enemy forts between start and destination
All enemy forts on the path are automatically captured ⚔️

Goal: Return the maximum number of enemy forts you can capture in a single movement. If no valid movement exists, return 0.

Input & Output

example_1.py — Basic capture scenario

$ Input: [1,0,0,-1,0,0,1,0,0,1]

› Output: 2

💡 Note: Move army from fort at position 0 to empty position 3, capturing 2 enemy forts at positions 1 and 2. This gives the maximum possible captures.

example_2.py — No valid moves

$ Input: [0,0,1,0,0]

› Output: 0

💡 Note: No empty positions (-1) available for army movement, so no captures are possible.

example_3.py — Multiple options

$ Input: [-1,1,0,0,0,-1]

› Output: 3

💡 Note: Move army from fort at position 1 to empty position 5, capturing all 3 enemy forts at positions 2, 3, and 4.

Constraints

1 ≤ forts.length ≤ 1000
forts[i] is either -1, 0, or 1
The array represents positions of forts on a battlefield
Movement constraint: Army can only travel through enemy territory

Visualization

Tap to expand

Understanding the Visualization

Battlefield Assessment

Survey the battlefield to identify friendly forts (green), enemy forts (red), and empty positions (gray)

Pattern Recognition

Look for valid movement patterns: friendly fort → enemy territory → empty position

Route Planning

Identify the route that passes through the maximum number of enemy forts

Execute Movement

Move army along the optimal path, capturing all enemies en route

Key Takeaway

🎯 Key Insight: Valid capture sequences follow a strict pattern of boundary → enemies → opposite boundary. By recognizing this pattern during a single scan, we achieve optimal O(n) time complexity.

Asked in

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

The optimal solution uses pattern recognition to identify valid capture sequences in O(n) time. By scanning the array once and looking for the pattern boundary → enemies → opposite boundary, we can efficiently find the maximum number of enemy forts that can be captured without checking all possible movement pairs.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs)	O(n²)	O(1)	Check every possible movement from friendly forts to empty positions
One Pass Scan (Optimal)	O(n)	O(1)	Scan array once looking for valid capture patterns: 1→0...0→-1 or -1→0...0→1

Brute Force (Check All Pairs) — Algorithm Steps

Find all friendly fort positions (value 1)
Find all empty positions (value -1)
For each friendly-empty pair, check the path between them
Count enemy forts if path contains only 0s between endpoints
Track the maximum count across all valid paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Starting Points

Locate all friendly forts (value 1) as potential starting positions

Find Destinations

Locate all empty positions (value -1) as potential destinations

Check Each Path

For each start-end pair, verify the path contains only enemy forts

Count Captures

Count enemy forts (value 0) along each valid path

Track Maximum

Keep track of the path with maximum enemy captures

Code -

solution.c — C

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

int captureForts(int* forts, int n) {
    int maxCaptures = 0;
    
    // Check all pairs of positions
    for (int i = 0; i < n; i++) {
        if (forts[i] == 1) { // Starting from friendly fort
            for (int j = 0; j < n; j++) {
                if (forts[j] == -1) { // Moving to empty position
                    // Check path between i and j
                    int start = (i < j) ? i : j;
                    int end = (i > j) ? i : j;
                    int valid = 1;
                    int enemyCount = 0;
                    
                    // Count enemies and check validity
                    for (int k = start + 1; k < end; k++) {
                        if (forts[k] == 0) {
                            enemyCount++;
                        } else {
                            valid = 0;
                            break;
                        }
                    }
                    
                    if (valid && enemyCount > 0 && enemyCount > maxCaptures) {
                        maxCaptures = enemyCount;
                    }
                }
            }
        }
    }
    
    return maxCaptures;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Parse input array
    int forts[100];
    int n = 0;
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        forts[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", captureForts(forts, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the potentially n friendly forts, we check each of the potentially n empty positions, and for each pair we scan the path between them

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track positions and counts, no additional data structures needed

✓ Linear Space

23.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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler