Manbers Algorithm In C++

In this guide, we will explore and elucidate the C++ implementation of Manber's Algorithm.

Introduction:

Manber's Algorithm is a technique for matching strings that identifies every instance of a pattern in a given text. This method, coined in honor of Udi Manber, the individual behind its creation in the year 1989, stands out as one of the most efficient approaches for this purpose. Operating with a time complexity of O(n+m), it proves valuable in domains like bioinformatics and extensive data handling frameworks.

Problem Statement:

Manber's algorithm is designed to tackle the challenge of identifying all instances of a specified pattern string P within a longer text string T. This task holds significant importance across various fields, including search engines, data management platforms, text manipulation software, and bioinformatics applications.

A conventional method that relies on brute-force techniques involves comparing every substring of the given text with the specified pattern. This process typically requires O(n*m) time complexity, where 'n' represents the size of the text 'T' and 'm' denotes the length of pattern 'P[4]'. Nonetheless, this technique proves to be ineffective when handling lengthy texts or when multiple patterns require simultaneous searching.

Conversely, Manber's algorithm exhibits a time complexity of O(n+m), with 'n' representing the text's length and 'm' denoting the pattern's length. This characteristic renders it particularly well-suited for fields that demand efficient string matching capabilities.

Example:

Let's consider a scenario to demonstrate the Manber's algorithm in the C++ programming language.

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

// Define a structure to represent a suffix
struct Suffix {
    int index; // Store the index of the suffix
    string suffix; // Store the suffix string itself
};

// Comparator function for sorting suffixes
bool compareSuffixes(const Suffix &a, const Suffix &b) {
    return a.suffix < b.suffix;
}

// Manber's Algorithm for finding pattern occurrences in text
void manberAlgorithm(const string &pattern, const string &text) {
    int n = text.length();
    int m = pattern.length();

    // Create a vector to store suffixes along with their indices
    vector<Suffix> suffixes(n);

    // Populate the suffix vector with suffixes of the text
    for (int i = 0; i < n; ++i) {
        suffixes[i].index = i;
        suffixes[i].suffix = text.substr(i);
    }

    // Sort the suffixes lexicographically
    sort(suffixes.begin(), suffixes.end(), compareSuffixes);

    // Iterate through the sorted suffixes to find matches
    for (int i = 0; i < n; ++i) {
        // Check if the current suffix matches the pattern
        if (suffixes[i].suffix.substr(0, m) == pattern) {
            cout << "Pattern found at index " << suffixes[i].index << "\n";
        }
    }
}

int main() {
    string text = "exampletextforpatternmatching";
    string pattern = "pattern";

    cout << "Text: " << text << "\n";
    cout << "Pattern: " << pattern << "\n\n";

    manberAlgorithm(pattern, text);

    return 0;
}

Output:

Text: exampletextforpatternmatching
Pattern: pattern

Pattern found at index 14

Explanation:

• ✅ Initial step The algorithm gets two strings as its input, one for searching and the other for being searched. Here, N is defined to be equal to the length of both the text and pattern (m).
• ✅ Generating Suffixes From each position i in text, this algorithm generates a suffix starting from that position and stores it with its indices in some array or vector kind of structure which consist of structs. For example, if 'text' is "example" and i==2, the suffix at index 2 would be "ample".
• ✅ Sorting Suffixes After creating all these suffixes, the Algorithm sorts them lexicographically based on their suffix strings. This sorting ensures optimized performance by Manber Algorithm.
• ✅ Pattern Matching During the sorting process, while going through every sorted suffice, check whether the first m characters of each possible suffix match the pattern. If they do not match anything else but another character string within any true case, original text matches should be reported.
• ✅ The algorithm gets two strings as its input, one for searching and the other for being searched.
• ✅ Here, N is defined to be equal to the length of both the text and pattern (m).
• ✅ From each position i in text, this algorithm generates a suffix starting from that position and stores it with its indices in some array or vector kind of structure which consist of structs.
• ✅ For example, if 'text' is "example" and i==2, the suffix at index 2 would be "ample".
• ✅ After creating all these suffixes, the Algorithm sorts them lexicographically based on their suffix strings. This sorting ensures optimized performance by Manber Algorithm.
• ✅ During the sorting process, while going through every sorted suffice, check whether the first m characters of each possible suffix match the pattern.
• ✅ If they do not match anything else but another character string within any true case, original text matches should be reported.

Time Complexity:

• ✅ Suffix generation from text takes O(n) time where n is the length of the text.
• ✅ It requires O(nlogn) time to sort the suffixes with a perfect sorting algorithm such as QuickSort or MergeSort.
• ✅ The comparison of patterns to sorted suffix subsets is part of the pattern matching phase. In this instance, if the text has k occurrences of this pattern, this step will take O(k⋅m), where m represents pattern length.
• ✅ Hence, Manber's Algorithm overall time complexity can be given as O(nlogn+k⋅m).

Space Complexity:

• ✅ This algorithm uses extra memory for storing indices and suffixes. Here, the space complexity is O(n), where n is the size of input string.
• ✅ Other variables that are used by an algorithm, like iterators and temporary strings, need a fixed amount of space.
• ✅ So, total space complexity still remains at O(n).

Advantages of the Manber's Algorithm:

Several advantages of the Manber's Algorithm are as follows:

• ✅ Linear Time Complexity: Manber's Algorithm achieves linear time complexity in practical scenarios, especially when the number of pattern occurrences is small compared to text size. This efficiency is essential for processing large texts fastly.
• ✅ Efficient Pre-processing: The algorithm pre-processes by sorting text suffixes, which can be done in O(nlogn) using efficient sorting algorithms. Once we have sorted these suffixes, it makes pattern matching stage much faster.
• ✅ Suitable for Various Patterns: Manber's Algorithm can be modified to effectively deal with multiple pattern searches. Instead of re-computing the whole text many times, we pre-process it once and then perform multiple pattern searches using sorted suffixes.
• ✅ Efficiency of Memory: The space complexity of Manber's Algorithm is O(n) , where n represents the length of the text.
• ✅ Multi-Purpose: The Manber's algorithm is versatile enough that it can be used in different types of string matching, such as exact matching or searching for substrings among other more complicated patterns.
• ✅ Amendable to Optimizations: Although the basic version of Manber's Algorithm provides efficient string-matching capability, there are additional techniques that can be applied to optimize its performance under certain conditions like skipping or early stopping.
• ✅ Usefulness in Bioinformatics: In bioinformatics, Manber's Algorithm has been widely utilized when dealing with DNA sequence comparisons because fast string matching is crucial for analysing big genetic data sets.
• ✅ Clear Implementation: The algorithm's logic is relatively straightforward and can be implemented using standard programming constructs and data structures, making it accessible to developers and researchers.

Disadvantages of the Manber's Algorithm:

Several disadvantages of the Manber's Algorithm are as follows:

• ✅ Use of Memory: Manber's Algorithm has an average space complexity of O(n) , which means that it saves a considerable amount of information, especially when dealing with long texts. This is not good for devices with small memory capacities.
• ✅ Time Complexities in the Worst Case: When the pattern occurrences increase linearly with the size of the text, Manber's Algorithm can take as long as O(n2) . Each suffix may have to be compared against the pattern to achieve this.
• ✅ Unsuitability for Sparse Patterns: The algorithm may not be best suited for patterns that are sparsely distributed within the text. In such scenarios, all suffixes sorting and processing overheads might not be worth its whiles.
• ✅ Restricted to Exact Matches: The basic version of Manber's Algorithm can perform only exact match searches in which a substring of the text must match an entire pattern. For more complicated types like approximate or fuzzy matching, extra modifications will have to be made.
• ✅ Sensitive to Patterns and Text Structure: The algorithm can have different results depending on the text structure and patterns. Some text characteristics or patterns may cause inefficient sorting and matching processes or overhead in them.
• ✅ Pre-processing Overhead: It is about the initial step of pre-processing, which sorts suffixes, especially for large texts. Such an overhead is normally compensated by the efficiency achieved during pattern matching, but it should still be considered, particularly for real-time or performance-critical applications.
• ✅ Complexity in Handling Updates: When we have dynamic text or patterns that need frequent updating, keeping sorted suffixes up-to-date efficiently becomes a problem. This aspect becomes more significant if we talk about those applications where either text indexing or real-time updates are required.
• ✅ Optimization Dependencies: In order to achieve optimal performance with Manber's Algorithm there are often additional optimizations needed, such as using specialized data structures like suffix arrays or efficient comparison strategies being implemented. However, these optimizations could complicate the implementation and maintenance of the algorithm.

Conclusion:

In summary, Manber's Algorithm stands out as a notable string-matching technique that identifies every instance of a pattern within a provided text.