如何使用C++找到第一个最长的连续等于substring？

Question

How to find the first longest consecutive equal substring using C++?

The program asks the user to input the string to evaluate, then outputs the longest consecutive equal substring.

---

Sample input 1:

String to evaluate: abcabc

Sample output 1:

Longest Consecutive Equal Substring Found: abc

---

Sample input 2:

String to evaluate: HeyThereHeyThere123JJJ123JJJ

Sample output 2:

Longest Consecutive Equal Substring Found: HeyThere

Answer 1

There are several possible design approaches. Here the major 3:

1. Brute force. This needs a triple nested loop and has a complexity of O(n^3). It may work for small strings, but will soon fail with strings getting bigger
2. Using dynamic programming. The complexity is only quadratic O(n^2). But it also needs a 2 dimension DP table for all characters of the source string.
3. Suffix trees, with a linear runtime. But hard to implement and hard to understand. Please read here about suffix trees and here about Ukkonen's algorithm. But as said, this is some heavy stuff.

The compromise proposal is number 2, dynamic programming. How does this work? Let's see. First we will iterate over all characters in an outer loop, and then, with a nested loop, all characters following the character under evaluation from the outer loop. So, if we have xabcyabcz, then we will start with the 'x' and compare it with 'a','b','c','y','a','b','c','z'. We will find no match.

Next, we will advance one character given by the outer loop, in this example with 'a'. This we will compare with 'b','c','y','a','b','c','z'. We will find one match and start to do activities.

First, we check, if there is a potential overlap. This we see, if we compare the distance of the 2 indices of the found 'a's with the current maximum found substring length. If the values are equal, then the overlaps starts. We can decide, if we want to allow overlaps or not.

Now, the counting of the maximum length of an equal substring. We found the 'a' and a matching 'a'. We will increment the substring length with the length that we found for the previous character. That was 0. So, now, for this 'a', we store a length of 0+1=1. Next, when we evaluate the 'b' given by the outer loop and find a match later in the string, then we increment the string length for 'b' with that from the previos character 'a', that was 1, and will now have 1+1=2 for 'b'.

All this will be continued until all characters are checked.

We will memorize the maximum found string length, and an index in the given string to check, for the maximum length substring.

At the end, we simple build a substring of the input string, with the given parameters.

All this (oand this is one patential solution) could be done like the below:

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

std::string getLongestConsecutiveEqualSubstring(const std::string& stringToCheck) {

    // We need to use the strings length more often. So read the function here only once.
    const size_t testStringLength = stringToCheck.length();

    // Table to store length values for sub strings. 2d vector. Initialize with 0
    std::vector< std::vector<unsigned int>> commonSubStringLength(testStringLength, std::vector<unsigned int>(testStringLength, 0u));

    // This will store the maximum length of an equal substring
    unsigned int maxLength = 0u; 
    // And this the index in the string to check. Index points to the last character of the found substring
    size_t indexLastLetterOfMax = 0u;

    // Temporary to handle negative indices
    unsigned int dummyLengthNull = 0u;

    // Iterate over string to check. Each character will be compared with all following charcters
    for (size_t indexFirst = 0; indexFirst < testStringLength; ++indexFirst) {
        for (size_t indexSecond = indexFirst + 1; indexSecond < testStringLength; ++indexSecond) {

            // These are just abbreviations with a pointer for easier access within the 2d vector
            unsigned int* const currentLength = &commonSubStringLength[indexFirst][indexSecond];
            // Since we start at index 0, there would be a problem with the "previous" length element
            // There for we simply point to a 0-element in such case
            const unsigned int*  previousLength{};
            if (indexFirst > 0)
                previousLength = &commonSubStringLength[indexFirst - 1][indexSecond - 1];
            else
                previousLength = &dummyLengthNull;

            // This will prevent overlapping findings lile for ababababab
            // You may set this to false, ant the algorithm will work with overlaps
            const bool overlap = ((indexSecond - indexFirst) < *previousLength);

            // So, if we have 2 identical characters in the string
            if (stringToCheck[indexFirst] == stringToCheck[indexSecond] and not overlap) {

                // Then we increase the length for this substring, with that from the character before
                *currentLength = *previousLength + 1;

                // And if we found new max sub string length
                if (*currentLength > maxLength) {

                    // Then we memorize the new length
                    maxLength = *currentLength;
                    // and the end-index in the given text for this substring
                    if (indexFirst > indexLastLetterOfMax) indexLastLetterOfMax = indexFirst;
                }
            }
            else
                // Else, the letter were different. So, length of substring will be zero
                *currentLength = 0;
        }
    }
    // Build and return substring from given parameters
    return stringToCheck.substr(indexLastLetterOfMax - maxLength + 1, maxLength);
}
// Test / Driver code
int main()
{
    std::string testString{ "HeyThereHeyThere123JJJ123JJJ" };
    std::cout << "Result: " << getLongestConsecutiveEqualSubstring(testString) << '\n';
}