ll t[N][N][N*N];// 本层 j 个点仅向上一层 i 连边，本层间不连边共有 k 条边的方案数。
ll g[N][N][N*N];// 本层 j 个点仅向上一层 i 连边，加上本层间的边共有 k 条边的方案数。
ll f[2][N][N][N][N*N]; //层数，奇数层点数，偶数层点数，本层有 l 个点，共 k 条边的方案数

Review how to find the length of an LCS of T and S.Taking a closer look at the transitions, we notice the following properties of the DP array:

Thus, there are only $dp_i$ possible patterns for $2^{|S|}$.

We use this fact to solve the original problem.

Let $DP_{i,dp\_array}$ be the number of strings $T$ of length $i$ such that $dp\_array$ is the DP array $dp_i$ when finding an LCS of $T$ and $S$.

The updates on $dp\_array$ as $i$ increases can be found according to the transitions of the DP for LCS described above.

There are $O(2^N)$ states for $DP_i$, and computing transitions of $dp\_array$ costs $O(\sigma N)$, so the overall complexity is $O(NM\sigma 2^N)$ (where $\sigma$ is the size of alphabet). By precalculating the transitions, the complexity can be reduced to $O(NM2^N)$.

Transposing the terms in $B-A = C-B$, we get $2B=A+C$.
First, let us count the number of integer pairs $(A,C)$ with $A,C \in S$ and $A+C=k$.

Note that the coefficient of the each term in the right hand side is no greater than $10^6$, so one may find the convolution modulo $998244353$ (which we can directly obtain with the convolution function in ACL).

For a lowercase English letter $c$ and a palindrome $S$, the string obtained by concatenating $c$, $S$, and $c$ in this order forms a palindrome. Conversely, a string of length at least two is a palindrome if and only if the first and the last characters are the same, and the string obtained by removing the first and last characters still forms a palindrome.

Using these properties, the problem can be formalized as a shortest path problem on a (directed) graph.

Let $G$ be a graph with $N^2$ vertices $\lbrace (1,1), (1,2), \ldots, (1, N), (2, 1), \ldots, (N, N) \rbrace$. We will decide the edges so that vertex $(i, j)$ corresponds to a path from vertex $i$ to vertex $j$ in the graph given in the problem statement.

For convenience, add another vertex $S$ to $G$ for it to have $N^2 + 1$. Then the answer to the original problem for an integer pair $(i, j)$ is the length of a shortest path from $S$ to $(i, j)$ in the graph with edges added as follows:

• An edge from $S$ to $(i, i)$ of weight $0$ for each $i$.
• An edge from $S$ to $(i, j)$ of weight $1$ for each $(i, j)$ with $C_{i, j} \neq$ -.
• An edge from $(i, j)$ to $(k, l)$ of weight $2$ for each $(i, j, k, l)$ with $C_{k, i} \neq$ -, $C_{j, l} \neq$ -, $C_{k, i} = C_{j, l}$.

The edges of the first kind represent the palindrome of length $0$, and those for the second represent those of length $1$. The edges of the third kind correspond to adding the same character at the beginning and the end of a palindrome to obtain a new palindrome with the length increased by two.

$G$ has $O(N^2)$ vertices, each of degree $O(N^2)$, so it has $O(N^4)$ edges, allowing $O(N^4)$-time BFS (Breadth-First Search) to find the answer.

Note that although the edges are weighted, one can still find the shortest distances by processing those with weight $0$ and $1$ first.

ll nw=0;
For(i,1,ce)
{
    int p1=lower_bound(d+1,d+1+cd,e[i])-d;
    int p2=lower_bound(d+1,d+1+cd,-e[i])-d;
    ll del=(p2-p1)*e[i]+(pred[p1-1]+nw+e[i]+sum)+(pred[p2-1]+nw+sum);
    if(del>0) break;
    nw+=e[i],ans+=del;
}
write(ans),End;

ll nw=0,res=ans;
For(i,1,ce)
{
    int p1=lower_bound(d+1,d+1+cd,e[i])-d;
    int p2=lower_bound(d+1,d+1+cd,-e[i])-d;
    ll del=(p2-p1)*e[i]+(pred[p1-1]+nw+e[i]+sum)+(pred[p2-1]+nw+sum);
    nw+=e[i],ans+=del,res=min(res,ans);
}
write(res),End;