Exactly my thought, it's two problems in one. I came for inheritance but I found the most complex part was the LCS.

Very true. Also didn't think I'd see Peter Sommerlad here!

I feel like I've been seeing a lot of red flags like this in the discussion for almost every question. It does make me pretty concerned since I'm using this site to practice for interviews. Does anyone have other suggestions for websites or books to practice C++?

Hi Alexhans,
check the wikipedia page for the Longest Common Subsequent problem: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
You have to find the length of the longest subsequence common to the both of the strings, and it's different from the problem of finding common substrings: unlike substrings, subsequences are not required to occupy consecutive positions.

Subsequence definition: "In mathematics, a subsequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements".

Consider X = XMJYAUZ and Y = MZJAWXU
The longest common subsequence between X and Y is MJAU

As you can see, in the subsequences there can be missing chars (compared to the original strings), but the important thing is that any char in the common subsequence is present in both the input strings (in the same order).

counterspell:

if (Fireball *fb=dynamic_cast<Fireball*>(spell)) {
    fb->revealFirepower();
} 
else if (Frostbite *fz=dynamic_cast<Frostbite*>(spell)) {
    fz->revealFrostpower();
} 
else if (Thunderstorm *ts=dynamic_cast<Thunderstorm*>(spell)) {
    ts->revealThunderpower();
} 
else if (Waterbolt *wb=dynamic_cast<Waterbolt*>(spell)) {
    wb->revealWaterpower();
}
else { // generic spell
    string spellN = spell->revealScrollName();
    string spellJ = SpellJournal::read();
    int m=spellN.length();
    int n=spellJ.length();
    int array[m+1][n+1]; 

    // solve for LCS
    for (int i=0;i<=m;i++) array[i][0]=0;
    for (int j=0;j<=n;j++) array[0][j]=0;
    for (int i=1;i<=m;i++) {
        for (int j=1;j<=n;j++) {
            if (spellN[i-1] == spellJ[j-1])
                array[i][j]=array[i-1][j-1]+1;
            else
                array[i][j]=max(array[i][j-1],array[i-1][j]);
        }
    }  
    cout << array[m][n] << endl; 
}

Exactly! i had never solved LCS non recursively. Quite interesting.

the recursive relation for LCS can naturally be translated to an iterative non-recursive algorithm for successively filling up the memo table of subproblem answers. That can be done with a simple C-style double nested for loop, and doesn't require defining external functions or fancy lambdas / functors.

You can use a local struct type to define a local function within a function:

void counterspell(Spell *spell) {
    ...
    struct A {
        static size_t f(...) { ... }
    };
    size_t lcs = A::f(...);
    cout << lcs << endl;
}

you need to try the dynamic cast, because spell is a pointer if the cast fail the dynamic cast become NULL(for a reference it would be a bad_cast exception if i remember correctly) and you know now spell isn't the type that you try to cast, with if else statement and 4 dynamic cast you can arrive to determine what kind of spell it is! good luck for the LCS too after that

Fireball* fbl = dynamic_cast<Fireball*>(spell);

if(fbl==NULL){ Frostbite* fbi = dynamic_cast< Frostbite*>(spell); if(fbi==NULL){Thunderstorm* ts = dynamic_cast< Thunderstorm*>(spell); ...