序列问题

参考：

• 位运算求最长公共子序列 - -Wallace- - 博客园
• 最长不下降子序列 nlogn 算法详解 - lvmememe - 博客园

---

最长公共子序列

最长公共子序列问题

给定一个长度为 $n$ 的序列 $A$ 和一个 长度为 $m$ 的序列 $B$ （ $n,m\le 5000$ ），求出一个最长的序列，使得该序列既是 $A$ 的子序列，也是 $B$ 的子序列。

子序列的定义可以参考 子序列 。一个简要的例子：字符串 abcde 与字符串 acde 的公共子序列有 a 、 c 、 d 、 e 、 ac 、 ad 、 ae 、 cd 、 ce 、 de 、 ade 、 ace 、 cde 、 acde ，最长公共子序列的长度是 4。

设 $f(i,j)$ 表示只考虑 $A$ 的前 $i$ 个元素， $B$ 的前 $j$ 个元素时的最长公共子序列的长度，求这时的最长公共子序列的长度就是 子问题 。 $f(i,j)$ 就是我们所说的 状态 ，则 $f(n,m)$ 是最终要达到的状态，即为所求结果。

对于每个 $f(i,j)$ ，存在三种决策：如果 $Ai=Bj$ ，则可以将它接到公共子序列的末尾；另外两种决策分别是跳过 $Ai$ 或者 $Bj$ 。状态转移方程如下：

f(i,j)={f(i−1,j−1)+1Ai=Bjmax(f(i−1,j),f(i,j−1))Ai≠Bj

可参考 SourceForge 的 LCS 交互网页 来更好地理解 LCS 的实现过程。

该做法的时间复杂度为 $O(nm)$ 。

另外，本题存在 $O(nmw)$ 的算法 [^1] 。有兴趣的同学可以自行探索。

int a[MAXN], b[MAXM], f[MAXN][MAXM];
 
int dp() {
  for (int i = 1; i <= n; i++)
    for (int j = 1; j <= m; j++)
      if (a[i] == b[j])
        f[i][j] = f[i - 1][j - 1] + 1;
      else
        f[i][j] = std::max(f[i - 1][j], f[i][j - 1]);
  return f[n][m];
}

最长不下降子序列

最长不下降子序列问题

给定一个长度为 $n$ 的序列 $A$ （ $n\le 5000$ ），求出一个最长的 $A$ 的子序列，满足该子序列的后一个元素不小于前一个元素。

算法一

设 $f(i)$ 表示以 $Ai$ 为结尾的最长不下降子序列的长度，则所求为 $max1\le i\le nf(i)$ 。

计算 $f(i)$ 时，尝试将 $Ai$ 接到其他的最长不下降子序列后面，以更新答案。于是可以写出这样的状态转移方程： $f(i)=max1\le j<i,Aj\le Ai(f(j)+1)$ 。

容易发现该算法的时间复杂度为 $O(n2)$ 。

int a[MAXN], d[MAXN];
 
int dp() {
  d[1] = 1;
  int ans = 1;
  for (int i = 2; i <= n; i++) {
    d[i] = 1;
    for (int j = 1; j < i; j++)
      if (a[j] <= a[i]) {
        d[i] = max(d[i], d[j] + 1);
        ans = max(ans, d[i]);
      }
  }
  return ans;
}

算法二

当 $n$ 的范围扩大到 $n\le 105$ 时，第一种做法就不够快了，下面给出了一个 $O(nlogn)$ 的做法。

回顾一下之前的状态： $(i,l)$ 。

但这次，我们不是要按照相同的 $i$ 处理状态，而是直接判断合法的 $(i,l)$ 。

再看一下之前的转移： $(j,l-1)\to (i,l)$ ，就可以判断某个 $(i,l)$ 是否合法。

初始时 $(1,1)$ 肯定合法。

那么，只需要找到一个 $l$ 最大的合法的 $(i,l)$ ，就可以得到最终最长不下降子序列的长度了。

那么，根据上面的方法，我们就需要维护一个可能的转移列表，并逐个处理转移。

所以可以定义 $a1\dots an$ 为原始序列， $di$ 为所有的长度为 $i$ 的不下降子序列的末尾元素的最小值， $len$ 为子序列的长度。

初始化： $d1=a1,len=1$ 。

现在我们已知最长的不下降子序列长度为 1，那么我们让 $i$ 从 2 到 $n$ 循环，依次求出前 $i$ 个元素的最长不下降子序列的长度，循环的时候我们只需要维护好 $d$ 这个数组还有 $len$ 就可以了。 关键在于如何维护。

考虑进来一个元素 $ai$ ：

1. 元素大于等于 $dlen$ ，直接将该元素插入到 $d$ 序列的末尾。
2. 元素小于 $dlen$ ，找到 第一个 大于它的元素，用 $ai$ 替换它。

为什么：

• 对于步骤 1： 由于我们是从前往后扫，所以说当元素大于等于 $dlen$ 时一定会有一个不下降子序列使得这个不下降子序列的末项后面可以再接这个元素。如果 $d$ 不接这个元素，可以发现既不符合定义，又不是最优解。
• 对于步骤 2： 同步骤 1，如果插在 $d$ 的末尾，那么由于前面的元素大于要插入的元素，所以不符合 $d$ 的定义，因此必须先找到 第一个 大于它的元素，再用 $ai$ 替换。

步骤 2 如果采用暴力查找，则时间复杂度仍然是 $O(n2)$ 的。但是根据 $d$ 数组的定义，又由于本题要求不下降子序列，所以 $d$ 一定是 单调不减 的，因此可以用二分查找将时间复杂度降至 $O(nlogn)$ .

参考代码如下：

for (int i = 0; i < n; ++i) scanf("%d", a + i);
memset(dp, 0x1f, sizeof dp);
mx = dp[0];
for (int i = 0; i < n; ++i) {
  *std::upper_bound(dp, dp + n, a[i]) = a[i];
}
ans = 0;
while (dp[ans] != mx) ++ans;

注意

对于最长 上升 子序列问题，类似地，可以令 $di$ 表示所有长度为 $i$ 的最长上升子序列的末尾元素的最小值。

需要注意的是，在步骤 2 中，若 $ai\le dlen$ ，由于最长上升子序列中相邻元素不能相等，需要在 $d$ 序列中找到 第一个 不小于 $ai$ 的元素，用 $ai$ 替换之。

在实现上（以 C++ 为例），需要将 upper_bound 函数改为 lower_bound 。