The editorial restricts the problem with a procedure, a procedure in which we will always extract the left-most characters of $$$S$$$ as we check for a subsequence.

In that way for each string $$$T$$$ there will be a unique pair $$$(i, j)$$$ of positions of $$$S$$$ that will be picked when forming a subsequence of $$$TT$$$ and will correspond to the positions of the first characters of each $$$T$$$ in the said procedure. In particular $$$i$$$ will be the first occurence of the first character of $$$T$$$, so the important part is $$$j$$$.

Now when counting $$$T$$$ we know that it will correspond to a specific $$$j$$$. Finding all such $$$T$$$ for a specific $$$j$$$ and summing up is now possible, since doing so we will eventually cover all strings.

Let $$$n_c(i)$$$ be the index of the first occurence of $$$c$$$ in $$$S[i\dots N]$$$ ($$$N = |S|$$$)

Also let $$$I(c)$$$ be the array/set of all indices $$$i$$$ such that $$$S[i] = c$$$.

The main idea is that we want to count the number of strings $$$T$$$ such that $$$TT$$$ is a subsequence of $$$S$$$ and which start with $$$c\in\Sigma = \{a, \dots, z\}$$$, and we will sum the answers iterating $$$c$$$ through all of $$$\Sigma$$$.

Obviously if $$$T=cT'$$$ then $$$TT=cT'cT'$$$ so if $$$TT$$$ is a subsequence of $$$S$$$ then there is a pair $$$(i, j)$$$ with $$$i<j$$$ such that $$$S[i], S[j]$$$ are the first character of each $$$T$$$ in $$$TT$$$. Wlog we can assume that for finding a subsequence for $$$TT=cT'cT'$$$, we will always pick the first $$$c$$$ of $$$S$$$ so $$$i=i_0=n_c(1)$$$ in that pair (and it is fixed).

(Note that we will overcount, but will sieve later)

Let's iterate through all $$$j\in I(c)\setminus \{i_0\}$$$ (through all other positions of $$$c$$$). We fix $$$j$$$, now if $$$(i_0,j)$$$ is the pair corresponding to the first $$$c$$$-characters of each of $$$T$$$ in $$$TT$$$ then how many different $$$T'$$$ are there such that $$$TT = cT'cT'$$$ is a subsequence of $$$S$$$? First of all we can count the case where $$$T' = \emptyset$$$ but then there may be non-empty $$$T'$$$. Notice that the first $$$T'$$$ will be a subsequence of $$$S[i_0+1\dots j-1]$$$ and the second will be a subsequence of $$$S[j+1\dots N]$$$, in fact we can count all such strings and each one of those will result in a different $$$TT$$$. It is easier to count such strings than in the original problem since the segments for each repetiotion of $$$T'$$$ are disjoint. There are $$$G_{j-1}(i_0+1, j+1)$$$ such strings, where $$$G: [N]^3 \to \mathbb{Z}$$$ is defined as follows:

Let $$$G_m(i, j) = ($$$number of strings $$$T'$$$ such that $$$T'$$$ is a subsequence of both $$$S[i\dots m]$$$ and $$$S[j\dots N])$$$ We can recursively compute the function as

by applying same logic as before, i.e count the number of strings for each different starting character $c$, but now we will suppose that we pick the first occurence of that character in each of the two disjoint segments in the procedure of finding subsequences. That way we will not overcount in the computation of $$$G$$$. The total computation time is $$$\Theta (|\Sigma|N^3)$$$ [ $$$=\Theta (N^3)$$$ since $$$|S|=26$$$ ] which is the most costly part of the solution and so the solution itself has the same time complexity, which is identical to the editorial.

Just summing the answers for pairs $$$(i_0, j)$$$ will result in overcounting. How much? Suppose that for a character $$$c$$$ (and $$$i_0 = n_c(1)$$$) you count the contribution of the pairs $$$(i_0, j)$$$ and $$$(i_0, k)$$$ with $$$i_0 < j < k$$$. Every string $$$T'$$$ will be counted in both cases if and only if it is a subsequence of $$$S[i_0+1\dots j-1]$$$ and $$$S[k+1\dots N]$$$ (you can draw a picture to see this, even though it seems trivial I was confused about this at first).

So in order to count the number of string $$$T$$$ in the original problem we can do the following

For each $$$c\in\Sigma$$$ ($$$i_0 := n_c(1)$$$) iterate $$$i$$$ through all positions of $$$c$$$ (excluding $$$i_0$$$) from smallest to largest and add the "overcounted contribution" of the pair $$$(i_0, i)$$$ as described with the function $$$G$$$. After the first iteration of $$$i$$$ we will also remove the contribution we may had also counted with the previous pair as described above. Doing so, one can prove that in each stage of iteration of $$$i$$$ we will not have overcounted, and we will eventually count all strings starting with the character $$$c$$$ (since each string will corespond to some pair $$$(i_0, \cdot)$$$.

Here is my submission where I use more or less the same notation (maybe with some minor differences).