Codestin Search App

Alternating Groups III - Problem

Imagine you're looking at a beautiful circular mosaic made of red and blue tiles. Your task is to analyze patterns in this circular arrangement and make dynamic changes to it!

You are given a circular array colors where each tile is either red (0) or blue (1). An alternating group is a contiguous sequence of tiles where adjacent tiles have different colors - like a perfect checkerboard pattern.

You need to handle two types of queries:

Type 1: [1, size] - Count how many alternating groups of the given size exist in the circle
Type 2: [2, index, color] - Change the tile at position index to the specified color

Return an array containing the results of all Type 1 queries in order. Remember, since the tiles form a circle, the first and last tiles are neighbors!

Input & Output

example_1.py — Basic Alternating Pattern

$ Input: colors = [0,1,1,0,1], queries = [[2,1,0],[1,4],[1,3]]

› Output: [1, 2]

💡 Note: Initially: [0,1,1,0,1]. After query [2,1,0]: [0,0,1,0,1]. Query [1,4] asks for groups of size 4 - there's 1 such group starting at index 1. Query [1,3] asks for groups of size 3 - there are 2 such groups.

example_2.py — All Same Color

$ Input: colors = [0,0,0,0], queries = [[1,3],[2,0,1],[1,3]]

› Output: [0, 0]

💡 Note: Initially all tiles are red [0,0,0,0], so no alternating groups exist. After changing index 0 to blue: [1,0,0,0], still no alternating groups of size 3 exist.

example_3.py — Perfect Alternating Circle

$ Input: colors = [0,1,0,1], queries = [[1,2],[1,3],[1,4]]

› Output: [4, 4, 4]

💡 Note: The circle [0,1,0,1] is perfectly alternating. There are 4 groups of size 2, 4 groups of size 3, and 4 groups of size 4 (since we can start at any position).

Constraints

1 ≤ colors.length ≤ 5 × 10⁴
0 ≤ colors[i] ≤ 1
1 ≤ queries.length ≤ 5 × 10⁴
queries[i][0] ∈ {1, 2}
Type 1: 1 ≤ queries[i][1] ≤ colors.length
Type 2: 0 ≤ queries[i][1] < colors.length, 0 ≤ queries[i][2] ≤ 1

Visualization

Tap to expand

Understanding the Visualization

Build Initial State

Analyze the circular array to identify alternating segments

Handle Type 1 Queries

Count alternating groups of the specified size using segment information

Handle Type 2 Updates

Update colors and efficiently recompute affected segments

Maintain Circular Property

Ensure the first and last elements are treated as neighbors

Key Takeaway

🎯 Key Insight: By tracking alternating segments instead of checking every position, we can efficiently handle both dynamic updates and range queries in logarithmic time.

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 15

The optimal approach uses segment tracking to efficiently handle dynamic updates and queries. By maintaining alternating segments and using advanced data structures like Fenwick Trees, we can answer each query in O(log N) time, making it scalable for large inputs with many operations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Positions)	O(Q × N × S)	O(1)	For each query, check every possible starting position and count alternating groups
Segment Tracking with Fenwick Tree (Optimal)	O(Q log N)	O(N)	Maintain alternating segments and use Fenwick Tree for efficient range queries

Brute Force (Check All Positions) — Algorithm Steps

For each Type 1 query, iterate through all positions as potential starting points
For each starting position, check if we can form an alternating group of the required size
Count valid alternating groups by checking adjacent colors differ
Handle circular nature by using modulo operations
For Type 2 queries, directly update the colors array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position 0

Check if we can form alternating group starting at position 0

Start Position 1

Move to next position and repeat the check

Continue Around Circle

Check all positions in the circular array

Code -

solution.c — C

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

int countAlternatingGroups(int* colors, int n, int size) {
    if (size > n) return 0;
    
    int count = 0;
    for (int start = 0; start < n; start++) {
        int valid = 1;
        for (int i = 0; i < size - 1; i++) {
            int pos1 = (start + i) % n;
            int pos2 = (start + i + 1) % n;
            if (colors[pos1] == colors[pos2]) {
                valid = 0;
                break;
            }
        }
        if (valid) count++;
    }
    return count;
}

int* alternatingGroups(int* colors, int colorsSize, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    int* result = (int*)malloc(queriesSize * sizeof(int));
    int resultIndex = 0;
    
    for (int i = 0; i < queriesSize; i++) {
        if (queries[i][0] == 1) {
            result[resultIndex++] = countAlternatingGroups(colors, colorsSize, queries[i][1]);
        } else {
            colors[queries[i][1]] = queries[i][2];
        }
    }
    
    *returnSize = resultIndex;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(Q × N × S)

Q queries, each checking N positions, with S size validation steps

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters and variables

✓ Linear Space

24.5K Views

Medium Frequency

~25 min Avg. Time

890 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 Positions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler