CF1562E

最新推荐文章于 2024-11-18 20:06:38 发布

原创最新推荐文章于 2024-11-18 20:06:38 发布 · 146 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#动态规划

codeforce 专栏收录该内容

8 篇文章

订阅专栏

本文讲解了一种改进的算法，如何将寻找字符串序列中最长递增子序列的时间复杂度从O(n^2)降低到O(1)，利用字典序和最长公共前缀来实现高效比较。通过实例和状态转移方程详细阐述了如何处理重复元素，最终通过代码实现展示了这一优化过程。

题目大意

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

要找最长递增子序列

思路

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

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

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

Case1

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

Case2

如果 $S$ 中含有重复元素，设 $S = a a a a b$ ，如果包含“ $a, a a b$ ”，从“ $a$ ”的角度考虑，比" $a$ “字典序大的必定包含，那么必定包含“ $a, a a, a a a, a a b, a a a a, a a a a b$ ”，从” $a a b$ “的角度考虑，比“ $a a b$ ”字典序小的元素要包含，那么必定包含” $a, a a, a a b$ "，就会出现重复，即如果 $Ci,j≠0C_{i, j}\ne0$ ，那么就刚好要删除 $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]$ 也是会被选择的

于是我们设 $d p [i]$ 为以 $S [i : n]$ 这个后缀为结尾的最大答案，于是状态转移方程如下：
$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}}\}$

代码

#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;

    }
}