Minimum Number of Frogs Croaking

Minimum Number of Frogs Croaking - Problem

String Counting Medium

You are given the string croakOfFrogs, which represents a combination of the string "croak" from different frogs, that is, multiple frogs can croak at the same time, so multiple "croak" are mixed.

Return the minimum number of different frogs to finish all the croaks in the given string.

A valid "croak" means a frog is printing five letters 'c', 'r', 'o', 'a', and 'k' sequentially. The frogs have to print all five letters to finish a croak. If the given string is not a combination of a valid "croak" return -1.

Input & Output

Example 1 — Basic Overlapping

$ Input: croakOfFrogs = "croakcroak"

› Output: 1

💡 Note: One frog can say the entire sequence: first "croak" then second "croak". Only 1 frog needed.

Example 2 — Simultaneous Frogs

$ Input: croakOfFrogs = "crcoakroak"

› Output: 2

💡 Note: Need 2 frogs: Frog1 says "c-r-o-a-k" and Frog2 says "c-r-o-a-k" with interleaved timing.

Example 3 — Invalid Sequence

$ Input: croakOfFrogs = "croakcrook"

› Output: -1

💡 Note: Contains invalid character 'o' after 'o' - not following proper croak sequence.

Constraints

1 ≤ croakOfFrogs.length ≤ 10⁵
croakOfFrogs[i] is either 'c', 'r', 'o', 'a', or 'k'

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8 a Amazon 6

The key insight is to track frogs at each stage of the "croak" sequence using counters. As each character is processed, frogs transition between stages, and we track the maximum concurrent active frogs. Best approach is State Counter with Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force State Tracking

⏱️ Time: O(5ⁿ) Space: O(n)

For each character, try assigning it to any existing frog that can accept it, or create a new frog. Use backtracking to explore all possibilities and find the minimum number of frogs needed.

Stack-Based Validation

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

Treat each frog as a state machine and use a stack-like approach to ensure proper sequencing. Push frogs onto different state stacks and pop when transitioning to next state.

State Counter Approach

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

Use counters to track how many frogs are at each stage (c, cr, cro, croa). For each character, move frogs between stages and track the maximum concurrent frogs needed.

Brute Force State Tracking — Algorithm Steps

For each character, try assigning to existing frogs
If no frog can take it, create new frog
Use backtracking to find minimum frogs

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Assignment

For each character, try all possible frog assignments

Backtrack

If invalid, backtrack and try different assignment

Find Minimum

Return minimum frogs across all valid assignments

Code -

solution.c — C

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

int backtrack(char* s, int index, int* frogs, int frogCount, int len) {
    if (index == len) {
        for (int i = 0; i < frogCount; i++) {
            if (frogs[i] != 0) return 1000000;
        }
        return frogCount;
    }
    
    char c = s[index];
    char* croak = "croak";
    char* pos = strchr(croak, c);
    if (!pos) return 1000000;
    
    int neededState = pos - croak;
    int minFrogs = 1000000;
    
    // Try existing frogs
    for (int i = 0; i < frogCount; i++) {
        if (frogs[i] == neededState) {
            frogs[i] = (frogs[i] + 1) % 5;
            int result = backtrack(s, index + 1, frogs, frogCount, len);
            if (result < minFrogs) minFrogs = result;
            frogs[i] = neededState;
        }
    }
    
    // Try new frog
    if (c == 'c') {
        frogs[frogCount] = 1;
        int result = backtrack(s, index + 1, frogs, frogCount + 1, len);
        if (result < minFrogs) minFrogs = result;
    }
    
    return minFrogs;
}

int solution(char* croakOfFrogs) {
    int len = strlen(croakOfFrogs);
    int* frogs = (int*)malloc(len * sizeof(int));
    int result = backtrack(croakOfFrogs, 0, frogs, 0, len);
    free(frogs);
    return result == 1000000 ? -1 : result;
}

int main() {
    char croakOfFrogs[100001];
    fgets(croakOfFrogs, sizeof(croakOfFrogs), stdin);
    croakOfFrogs[strcspn(croakOfFrogs, "\n")] = 0;
    printf("%d\n", solution(croakOfFrogs));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(5ⁿ)

For each character, we try up to 5 different frog states, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth up to n characters plus frog state storage

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

856 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 State Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler