Aho-Corasick Multi-Pattern Search - Problem

The Aho-Corasick algorithm is a powerful string-searching algorithm that can search for multiple patterns simultaneously in a text. Unlike naive approaches that search for each pattern individually, Aho-Corasick constructs a finite automaton that processes the text in a single pass.

Given a text string and a list of pattern strings, implement the Aho-Corasick algorithm to find all occurrences of all patterns in the text. Return a list of results, where each result contains the pattern found and its starting position in the text.

Key components:

Trie construction - Build a prefix tree of all patterns
Failure function - Compute failure links using BFS
Pattern matching - Process text using the automaton

Note: The algorithm should handle overlapping matches and multiple patterns ending at the same position.

Input & Output

Example 1 — Basic Multi-Pattern Search

$ Input: text = "hershey", patterns = ["he", "she", "his", "hers"]

› Output: [["he",0],["hers",0],["she",3]]

💡 Note: Found 'he' at position 0, 'hers' at position 0 (overlapping), and 'she' at position 3. Pattern 'his' not found.

Example 2 — Overlapping Patterns

$ Input: text = "aaaa", patterns = ["a", "aa", "aaa"]

› Output: [["a",0],["a",1],["aa",0],["a",2],["aa",1],["aaa",0],["a",3],["aa",2]]

💡 Note: All overlapping occurrences are found: single 'a' at each position, 'aa' starting at positions 0,1,2, and 'aaa' at position 0.

Example 3 — No Matches

$ Input: text = "hello world", patterns = ["xyz", "abc"]

› Output: []

💡 Note: Neither pattern 'xyz' nor 'abc' exists in the text, so empty result is returned.

Constraints

1 ≤ text.length ≤ 10⁴
1 ≤ patterns.length ≤ 100
1 ≤ patterns[i].length ≤ 100
text and patterns[i] consist of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 45 M Microsoft 38 a Amazon 32 f Facebook 28

The Aho-Corasick algorithm is the optimal solution for multi-pattern string searching. It builds a trie with failure links that allows single-pass text processing without backtracking. Key insight: failure links enable efficient transitions between partial pattern matches. Time: O(n + m + z), Space: O(m)

Common Approaches

✓ Aho-Corasick Algorithm

⏱️ Time: O(n + m + z) Space: O(m)

Construct a trie of all patterns, compute failure function using BFS to create links between states, then process text in single pass using the automaton.

Brute Force Pattern Search

⏱️ Time: O(n × m × p) Space: O(1)

For each pattern, scan through the entire text checking every position for a match. This approach searches patterns independently without any optimization.

Aho-Corasick Algorithm — Algorithm Steps

Step 1: Build trie (prefix tree) from all patterns
Step 2: Compute failure links using BFS traversal
Step 3: Add output links for suffix patterns
Step 4: Process text using automaton, following failure links

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Trie

Create prefix tree of all patterns

Add Failure Links

Connect states for efficient transitions

Process Text

Single pass using automaton

Code -

solution.c — C

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

#define MAX_NODES 10000
#define MAX_PATTERNS 100
#define MAX_RESULTS 1000

typedef struct TrieNode {
    struct TrieNode* children[256];
    struct TrieNode* failure;
    char output[MAX_PATTERNS][100];
    int outputCount;
} TrieNode;

typedef struct {
    char pattern[100];
    int position;
} Result;

TrieNode nodes[MAX_NODES];
int nodeCount = 0;

TrieNode* newNode() {
    TrieNode* node = &nodes[nodeCount++];
    memset(node, 0, sizeof(TrieNode));
    return node;
}

int solution(const char* text, char patterns[][100], int patternCount, Result* results) {
    if (patternCount == 0) return 0;
    
    nodeCount = 0;
    TrieNode* root = newNode();
    
    // Build trie
    for (int p = 0; p < patternCount; p++) {
        TrieNode* node = root;
        int len = strlen(patterns[p]);
        for (int i = 0; i < len; i++) {
            unsigned char c = patterns[p][i];
            if (!node->children[c]) {
                node->children[c] = newNode();
            }
            node = node->children[c];
        }
        strcpy(node->output[node->outputCount], patterns[p]);
        node->outputCount++;
    }
    
    // Build failure function (simplified BFS)
    TrieNode* queue[MAX_NODES];
    int front = 0, rear = 0;
    
    for (int c = 0; c < 256; c++) {
        if (root->children[c]) {
            root->children[c]->failure = root;
            queue[rear++] = root->children[c];
        }
    }
    
    while (front < rear) {
        TrieNode* current = queue[front++];
        for (int c = 0; c < 256; c++) {
            if (current->children[c]) {
                TrieNode* child = current->children[c];
                queue[rear++] = child;
                
                TrieNode* failure = current->failure;
                while (failure && !failure->children[c]) {
                    failure = failure->failure;
                }
                child->failure = failure ? failure->children[c] : root;
                
                // Copy output from failure node
                for (int i = 0; i < child->failure->outputCount; i++) {
                    strcpy(child->output[child->outputCount], child->failure->output[i]);
                    child->outputCount++;
                }
            }
        }
    }
    
    // Search text
    int resultCount = 0;
    TrieNode* node = root;
    int textLen = strlen(text);
    
    for (int i = 0; i < textLen; i++) {
        unsigned char c = text[i];
        while (node && !node->children[c]) {
            node = node->failure;
        }
        
        if (!node) {
            node = root;
            continue;
        }
        
        node = node->children[c];
        
        for (int j = 0; j < node->outputCount; j++) {
            int patternLen = strlen(node->output[j]);
            int startPos = i - patternLen + 1;
            strcpy(results[resultCount].pattern, node->output[j]);
            results[resultCount].position = startPos;
            resultCount++;
        }
    }
    
    return resultCount;
}

int main() {
    char text[1000];
    fgets(text, sizeof(text), stdin);
    text[strcspn(text, "\n")] = 0;
    
    char patternsLine[1000];
    fgets(patternsLine, sizeof(patternsLine), stdin);
    patternsLine[strcspn(patternsLine, "\n")] = 0;
    
    char patterns[MAX_PATTERNS][100];
    int patternCount = 0;
    
    char* token = strtok(patternsLine + 1, ",");
    while (token && patternCount < MAX_PATTERNS) {
        int len = strlen(token);
        if (token[len-1] == ']') token[len-1] = 0;
        if (token[0] == '"') token++;
        if (token[strlen(token)-1] == '"') token[strlen(token)-1] = 0;
        strcpy(patterns[patternCount], token);
        patternCount++;
        token = strtok(NULL, ",");
    }
    
    Result results[MAX_RESULTS];
    int resultCount = solution(text, patterns, patternCount, results);
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        printf("[\"%s\",%d]", results[i].pattern, results[i].position);
        if (i < resultCount - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m + z)

n = text length, m = total pattern characters, z = number of matches

✓ Linear Growth

Space Complexity

O(m)

Trie structure stores all pattern characters plus failure links

✓ Linear Space

23.4K 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

Aho-Corasick Multi-Pattern Search - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Aho-Corasick Algorithm — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler