Maximize Subarrays After Removing One Conflicting Pair

Maximize Subarrays After Removing One Conflicting Pair - Problem

You are given an integer n which represents an array nums containing the numbers from 1 to n in order. Additionally, you are given a 2D array conflictingPairs, where conflictingPairs[i] = [a, b] indicates that a and b form a conflicting pair.

Remove exactly one element from conflictingPairs. Afterward, count the number of non-empty subarrays of nums which do not contain both a and b for any remaining conflicting pair [a, b].

Return the maximum number of subarrays possible after removing exactly one conflicting pair.

Input & Output

Example 1 — Basic Case

$ Input: n = 5, conflictingPairs = [[1,5], [2,3]]

› Output: 14

💡 Note: Remove [2,3] to get max subarrays. With only [1,5] remaining, we avoid subarrays containing both 1 and 5. Total subarrays = 15. Invalid subarrays containing both 1 and 5: start ≤ 1 and end ≥ 5, giving 1×1 = 1 invalid subarray. Valid count: 15 - 1 = 14.

Example 2 — Single Pair

$ Input: n = 4, conflictingPairs = [[2,4]]

› Output: 10

💡 Note: Only one pair to remove [2,4]. Total subarrays = 4×5/2 = 10. After removal, no constraints remain, so all 10 subarrays are valid.

Example 3 — Multiple Pairs

$ Input: n = 3, conflictingPairs = [[1,2], [2,3]]

› Output: 4

💡 Note: Remove [1,2] keeps [2,3]. Invalid subarrays contain both 2 and 3: positions 2×2=4, but total is only 6, so 6-2=4 valid. Remove [2,3] keeps [1,2]: 6-2=4 valid. Both give same result.

Constraints

2 ≤ n ≤ 10⁵
1 ≤ conflictingPairs.length ≤ 10⁵
conflictingPairs[i].length == 2
1 ≤ conflictingPairs[i][0], conflictingPairs[i][1] ≤ n
conflictingPairs[i][0] ≠ conflictingPairs[i][1]

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 15 a Amazon 10

The key insight is that removing different conflicting pairs results in different numbers of valid subarrays. We can use mathematical formulas to count valid subarrays efficiently: total subarrays minus invalid ones. Best approach uses mathematical counting instead of enumeration. Time: O(k²n), Space: O(k)

Common Approaches

✓ Brute Force Enumeration

⏱️ Time: O(n⁴) Space: O(1)

For each conflicting pair to remove, generate all possible subarrays and check if they violate any remaining constraints. Return the maximum count.

Mathematical Formula Approach

⏱️ Time: O(k²n) Space: O(k)

Instead of checking each subarray individually, use the principle that total subarrays minus invalid subarrays equals valid subarrays. Calculate invalid subarrays using inclusion-exclusion.

Brute Force Enumeration — Algorithm Steps

Iterate through each conflicting pair to remove
Generate all O(n²) subarrays
Check each subarray against remaining constraints
Count valid subarrays and track maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Remove Pair

Try removing conflicting pair [2,4]

Check Subarrays

Test all O(n²) subarrays against remaining constraints

Count Valid

Count subarrays that don't violate remaining pairs

Code -

solution.c — C

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

#define MAX_PAIRS 1000

typedef struct {
    int a, b;
} Pair;

int solution(int n, Pair conflictingPairs[], int numPairs) {
    int maxCount = 0;
    
    // Try removing each conflicting pair
    for (int removeIdx = 0; removeIdx < numPairs; removeIdx++) {
        int count = 0;
        
        // Check all possible subarrays
        for (int i = 1; i <= n; i++) {
            for (int j = i; j <= n; j++) {
                // Check if subarray [i, j] is valid
                bool valid = true;
                for (int k = 0; k < numPairs; k++) {
                    if (k != removeIdx) {
                        int a = conflictingPairs[k].a;
                        int b = conflictingPairs[k].b;
                        if (i <= a && a <= j && i <= b && b <= j) {
                            valid = false;
                            break;
                        }
                    }
                }
                if (valid) {
                    count++;
                }
            }
        }
        
        maxCount = maxCount > count ? maxCount : count;
    }
    
    return maxCount;
}

int parseConflictingPairs(const char* str, Pair pairs[]) {
    int numPairs = 0;
    if (strcmp(str, "[]") == 0) return 0;
    
    const char* p = str + 1; // Skip first '['
    
    while (*p && *p != ']') {
        if (*p == '[') {
            p++; // Skip '['
            int a = 0, b = 0;
            
            // Parse first number
            while (*p >= '0' && *p <= '9') {
                a = a * 10 + (*p - '0');
                p++;
            }
            
            // Skip comma
            while (*p == ',' || *p == ' ') p++;
            
            // Parse second number
            while (*p >= '0' && *p <= '9') {
                b = b * 10 + (*p - '0');
                p++;
            }
            
            pairs[numPairs].a = a;
            pairs[numPairs].b = b;
            numPairs++;
            
            // Skip ']'
            while (*p == ']') p++;
        }
        
        // Skip comma between pairs
        if (*p == ',') p++;
        
        // Skip any whitespace
        while (*p == ' ') p++;
    }
    
    return numPairs;
}

int main() {
    char line1[100], line2[10000];
    
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    int len1 = strlen(line1);
    if (len1 > 0 && line1[len1-1] == '\n') line1[len1-1] = '\0';
    
    int len2 = strlen(line2);
    if (len2 > 0 && line2[len2-1] == '\n') line2[len2-1] = '\0';
    
    int n = atoi(line1);
    
    Pair conflictingPairs[MAX_PAIRS];
    int numPairs = parseConflictingPairs(line2, conflictingPairs);
    
    int result = solution(n, conflictingPairs, numPairs);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

O(k) pairs to try × O(n²) subarrays × O(n) to check each subarray × O(k) remaining constraints

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for counting

✓ Linear Space

27.7K Views

Medium Frequency

~35 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 Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler