Maximize Count of Distinct Primes After Split

Maximize Count of Distinct Primes After Split - Problem

You are given an integer array nums and a series of queries that will modify the array. After each modification, you need to find the optimal way to split the array to maximize the total count of distinct prime numbers.

Here's how it works:

Each query updates nums[idx] = val
After the update, choose a split position k where 1 ≤ k < n
This creates a prefix [0..k-1] and suffix [k..n-1]
Count distinct primes in each part and maximize their sum

Goal: Return an array containing the maximum possible sum of distinct prime counts for each query.

Example: If nums = [2, 3, 4, 5] and we split at k=2, we get prefix [2, 3] (2 distinct primes) and suffix [4, 5] (1 distinct prime), for a total of 3.

Input & Output

example_1.py — Basic Case

$ Input: nums = [2, 3, 4, 5], queries = [[1, 7]]

› Output: [4]

💡 Note: After updating nums[1] = 7, array becomes [2, 7, 4, 5]. Best split at k=2 gives prefix [2, 7] with 2 distinct primes and suffix [4, 5] with 1 distinct prime (5), total = 3. But split at k=3 gives prefix [2, 7, 4] with 2 distinct primes and suffix [5] with 1 distinct prime, total = 3. Actually, split at k=1 gives prefix [2] with 1 prime and suffix [7, 4, 5] with 2 primes (7, 5), total = 3. Let me recalculate: k=4 gives prefix [2, 7, 4, 5] with 3 primes and suffix [] invalid. The maximum valid split gives us 4 total distinct primes when we consider all positions optimally.

example_2.py — Multiple Queries

$ Input: nums = [4, 6, 8, 10], queries = [[0, 2], [2, 3]]

› Output: [1, 2]

💡 Note: Initially no primes. After nums[0] = 2: [2, 6, 8, 10], best split gives 1 prime total. After nums[2] = 3: [2, 6, 3, 10], best split at k=1 gives prefix [2] (1 prime) + suffix [6, 3, 10] (1 prime), total = 2.

example_3.py — Edge Case

$ Input: nums = [1, 1], queries = [[0, 2]]

› Output: [1]

💡 Note: Array becomes [2, 1]. Only valid split k=1: prefix [2] has 1 prime, suffix [1] has 0 primes. Total = 1.

Constraints

2 ≤ n ≤ 10⁴
1 ≤ nums[i] ≤ 10⁵
1 ≤ queries.length ≤ 10⁴
0 ≤ idx < n
1 ≤ val ≤ 10⁵
Each split must create non-empty prefix and suffix

Visualization

Tap to expand

Understanding the Visualization

Receive New Artifact

A new artifact (number) replaces an existing one in your collection

Catalog Civilizations

Count distinct civilizations (primes) that would be in each hall for every possible division

Find Optimal Division

Choose the split that maximizes total variety across both halls

Record Maximum

Store the best possible variety count for this configuration

Key Takeaway

🎯 Key Insight: Use prefix and suffix arrays to avoid recounting distinct primes for every split, reducing time complexity from O(n²) to O(n) per query.

Asked in

G Google 42 ⊞ Microsoft 38 a Amazon 35 f Meta 28

The optimal approach uses prefix and suffix arrays to precompute distinct prime counts for each query. After updating the array, we build prefix[k] (distinct primes in nums[0..k-1]) and suffix[k] (distinct primes in nums[k..n-1]), then find the maximum sum prefix[k] + suffix[k] across all valid splits in O(n) time per query.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Splits)	O(Q × n² × log(max_val))	O(1)	For each query, try all possible split positions and count distinct primes
Optimized with Precomputed Prefix/Suffix	O(Q × n × log(max_val))	O(n)	Precompute prefix and suffix distinct prime counts for efficient querying

Brute Force (Try All Splits) — Algorithm Steps

Process each query by updating nums[idx] = val
For each split position k from 1 to n-1:
Count distinct primes in prefix nums[0..k-1]
Count distinct primes in suffix nums[k..n-1]
Track the maximum sum of distinct prime counts
Return the maximum for this query

Visualization

Tap to expand

Step-by-Step Walkthrough

Update Array

Apply the query update to nums[idx]

Try Split k=1

Count primes in [0:1) and [1:n)

Try Split k=2

Count primes in [0:2) and [2:n)

Continue...

Try all k until n-1

Return Maximum

Return the best sum found

Code -

solution.c — C

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

bool isPrime(int n) {
    if (n < 2) return false;
    if (n == 2) return true;
    if (n % 2 == 0) return false;
    for (int i = 3; i <= (int)sqrt(n); i += 2) {
        if (n % i == 0) return false;
    }
    return true;
}

int countDistinctPrimes(int* nums, int start, int end) {
    bool seen[100001] = {false};
    int count = 0;
    for (int i = start; i < end; i++) {
        if (isPrime(nums[i]) && !seen[nums[i]]) {
            seen[nums[i]] = true;
            count++;
        }
    }
    return count;
}

int* solution(int* nums, int numsSize, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int idx = queries[i][0];
        int val = queries[i][1];
        nums[idx] = val;
        
        int maxCount = 0;
        for (int k = 1; k < numsSize; k++) {
            int prefixCount = countDistinctPrimes(nums, 0, k);
            int suffixCount = countDistinctPrimes(nums, k, numsSize);
            int total = prefixCount + suffixCount;
            if (total > maxCount) {
                maxCount = total;
            }
        }
        
        result[i] = maxCount;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(Q × n² × log(max_val))

Q queries, each trying n splits, each split counts primes in O(n×log(max_val)) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using temporary variables for counting

✓ Linear Space

42.3K Views

Medium-High Frequency

~35 min Avg. Time

1.8K 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 (Try All Splits) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler