CF1562E

题目大意

定义一个拓展序列 为$S_1,S_1{S}_2,S_1...S_n,S_2,S_2...S_n,...,S_{n-1},S_{n-1}{S}_n,S_n$

要找最长递增子序列

思路

因为$n\le 5000$， 所以可以考虑$O(n^2)$ 做法，由于比较字符串大小的过程最坏是$O(n)$的所以我们试图找到一种$O(1)$的方法去比较字符串大小

考虑字典序的比较方法，找到两个字符串的公共前缀，然后比较公共前缀的后一个字母即可

设$C_{i,j}$为$S_i,S_j$开始的后缀的最长公共前缀的长度，例如"$aab$”, “$aaab$”，最长公共前缀长度为$2$，这一步通过观察可以发现，每一步比较都换转移为更小的子问题，所以可以使用dp来解决，状态转移方程如下：
$$C_{i,j}=\{\begin{array}{ll}{C}_{i+1,j+1}+1,& \text{if }{S}_i=S_j\\ 0,& \text{if }{S}_i\ne S_j\end{array}$$

Case1

设$S=abcdef$，假设这个序列的最长递增子序列里面含有"$a,b$"，那么必定含有"$ab,abc,abcd,abcde,abcdef$"都应该包含，即如果包含$a$，那么$a$之后所有的字符串都应该包括

Case2

如果$S$中含有重复元素，设$S=aaaab$，如果包含“$a,aab$”，从“$a$”的角度考虑，比"$a$“字典序大的必定包含，那么必定包含“$a,aa,aaa,aab,aaaa,aaaab$”，从”$aab$“的角度考虑，比“$aab$”字典序小的元素要包含，那么必定包含”$a,aa,aab$"，就会出现重复，即如果$C_{i,j}\ne 0$， 那么就刚好要删除$C_{i,j}$个重复元素

于是结论如下：

如果字串$s[l:r]$被选择了的话，那么$ S[ l : r + 1 ] ,S [ l : r + 2 ] , ⋯   , S [ l : n ] S[l:r+1],S[l:r+2],\cdots,S[l:n]S[l:r+1],S[l:r+2],⋯,S[l:n]$ 也是会被选择的

于是我们设$dp[i]$为以$S[i:n]$这个后缀为结尾的最大答案，于是状态转移方程如下：
d p [ i ] = m a x ( d p [ j ] − C i , j ) + ( n − i + 1 ) { 1 ≤ j ≤ i − 1 ∣ S j + C i , j < S i + C i , j } dp[i]= max(dp[j]-C_{i,j})+(n-i + 1) \{1\le j \le i - 1|S_{j + C_{i,j}} < S_{i + C_{i,j}}\} dp[i]=max(dp[j]−Ci,j​)+(n−i+1){1≤j≤i−1∣Sj+Ci,j​​<Si+Ci,j​​}

代码

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

using namespace std;

const int N = 5e3 + 10;

int n;
char s[N];
int lcp[N][N], dp[N];

void init ()
{
    for (int i = 0; i <= n + 1; i ++)
        for (int j = 0; j <= n + 1; j ++)
            lcp[i][j] = 0;

    for (int i = n; i >= 1; i --)
    {
        for (int j = n; j >= 1; j --)
        {
            if (s[i] == s[j])
                lcp[i][j] = lcp[i + 1][j + 1] + 1;
            else 
                lcp[i][j] = 0;
        }
    }
}

int main ()
{
    int T;
    cin >> T;
    while (T --)
    {
        cin >> n >> s + 1;
        init ();
        for (int i = 1; i <= n; i ++)
        {
            dp[i] = n - i + 1;
            for (int j = 1; j <= i - 1; j ++)
            {
                if (s[i + lcp[i][j]] > s[j + lcp[i][j]])
                    dp[i] = max (dp[i], dp[j] + n - i + 1 - lcp[i][j]);
            }
        }
        cout << *max_element (dp + 1, dp + 1 + n) << endl;

    }
}