【DP学习总结】LIS和LCS

W⁡angduoyu

已于 2022-02-23 23:15:46 修改

阅读量404

点赞数 1

分类专栏：动态规划文章标签：动态规划贪心算法算法

于 2021-12-08 17:30:21 首次发布

本文链接：https://blog.csdn.net/ecjtu2020/article/details/121788781

版权

动态规划同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

每日一题

4 篇文章 0 订阅

订阅专栏

文章目录

最长公共子序列
最长上升子序列
最大上升子序列和
最长公共上升子序列
m元上升子序列

最长公共子序列

子序列允许不连续。

定义：最长公共子序列，英文缩写为 $L C S$ （Longest Common Subsequence）。其定义是，一个序列 $S$ ，如果分别是两个或多个已知序列的子序列，且是所有符合此条件序列中最长的，则 $S$ 称为已知序列的最长公共子序列。

求两个序列的 $L C S$ ,用 $S_1,S_2$ 分别表示两个序列。那么可以定义 $f [i] [j]$ 表示 $S_1$ 的 $(1, i)$ 和S_2 $的 (1, j)$ 的最长公共子序列。那么容易得到：
$f[i][j]=\left\{ \begin{array}{cl} f[i - 1][j - 1] + 1 & S_1[i] == S_2[j] \\ max(f[i-1][j], f[i][j-1]) & S_1[i] != S_2[j] \\ \end{array} \right.$

伪代码：

for(int i = 1; i <= n; ++ i) {
	for(int j = 1; j <= m; ++ j) {
	if(s1[i - 1] == s2[j - 1]) f[i][j] = f[i - 1][j - 1] + 1;
	else f[i][j] = max(f[i - 1][j], f[i][j - 1]);
	}
}

时间复杂度: $\mathcal{O(n^2)}$
对于一些特殊的 $L C S$ ,我们有更优秀的 $\mathcal{O(nlogn)}$ 解法（结合接下来的 $L I S$ )

最长上升子序列

子序列允许不连续。

定义：最长上升子序列 $L I S$ （Longest Increasing Subsequence)，一个序列 $S$ 的一个子序列，这个子序列是严格（或者不严格）递增的，且长度最长。
介绍两种方法：1. $\mathcal{O(n^2)}$ 的DP 2. $\mathcal{O(nlogn)}$ 的贪心

$\mathcal{O(n^2)}$ 的DP
用f[i]表示 $(1, i)$ 且以a[i]结尾的 $L I S$ ,
计算： $f [i] = M a x (1, f [j] + 1)$ $\le j \le i$ & $a [i] > a [j]$
伪代码：

for(int i = 1; i <= n; ++ i) {
        f[i] = 1;
        for(int j = 1; j < i; ++ j) 
            if(a[i] > a[j]) f[i] = max(f[i], f[j] + 1);
    }

$\mathcal{O(nlogn)}$ 的贪心
参考博客以及OI-wiki
定义 $f$ 为当前的 $L I S$ 。初始化： $f_1=a_1,len=0$
然后对于每次的 $a_i$ ，我们将其放入 $f$ 中：
Ⅰ：如果 $f_{len} <= a_i$ , 直接加在序列后面即可. $f_{++len} = a_i$
Ⅱ：如果 $f_{len} > a_i$ , 那就在 $f$ 中找到第一个大于等于他的元素，替换掉。（如果是不是严格上升就找到第一个大于他的元素）
伪代码：

// version 1.0
memset(f, 0x3f, sizeof f);
int mx = f[0];
for (int i = 0; i < n; ++i) {
  *upper_bound(f, f + n, a[i]) = a[i];// 非严格上升
  *lower_bound(f, f + n, a[i]) = a[i];
}
ans = 0;
while (f[ans] != mx) ++ans;
//version 2.0
vector<int>  stk;
stk.push_back(a[1]);
for(int i = 2; i <= n; ++ i) {
	if(stk.back() <= a[i]) stk.push_back(a[i]);
	else *upper_bound(stk.begin(), stk.end(), a[i]) = a[i];
		*upper_bound(stk.begin(), stk.end(), a[i]) = a[i];// 非严格上升
}
cout << stk.size();

其实还有一种树状数组+DP的 $\mathcal{O(nlogn)}$ (~~贪心已经 $\mathcal{O(nlogn)}$ ~~了）

最大上升子序列和

跟最长上升字序列类似，时间复杂度: $\mathcal{O(n^2)}$
f[i]：表示 $\sim i$ 且结尾是a[i]的最大上升子序列和
计算： $+a[i])(1\le j \le i)$

#include <bits/stdc++.h>
using namespace std;

const int N = 1010;
int a[N], f[N], n;

int main() 
{
    cin >> n;
    int res = 0;
    for(int i = 1; i <= n; ++ i) cin >> a[i];
    for(int i = 1; i <= n; ++ i) {
        f[i] = a[i];
        for(int j = 1; j < i; ++ j)
            if(a[i] > a[j]) f[i] = max(f[i], f[j] + a[i]);
    }
    cout << *max_element(f + 1, f + 1 + n) << endl;
}

最长公共上升子序列

题目连接：Acwing 272
LCIS (最长公共上升子序列，Longest Common Increasing Subsequence)
与上面相似，用 $f [i] [j]$ 表示考虑a序列前 $i$ 个，b序列前 $j$ 个且以 $b [j]$ 结尾的所有方案中的LCIS
状态计算：

不考虑第 $i$ 个， $f [i] [j] = f [i - 1] [j]$
考虑第 $i$ 个， $0\le k < j)$

for(int i = 1; i <= n; ++ i) {
        for(int j = 1; j <= n; ++ j) {
            f[i][j] = f[i - 1][j];
            if(a[i] == b[j]) {
                for(int k = 0; k < j; ++ k) {
                    if(b[j] > b[k])
                        f[i][j] = max(f[i][j], f[i - 1][k] + 1);
                }
            }
        }
    }

易知上述代码时间复杂度为： $\mathcal{O(n^3)}$ 对于 $\ge 10^3$ 的范围就会的TLE了。
优化：
在选第 $i$ 个的时候，我们是需要 $\le k < j)$ 为上一个状态的最大值，我们可以利用一个变量存储下来，从而减少一层for

#include <bits/stdc++.h>
using namespace std;
const int N = 3010;
int a[N], b[N], f[N][N], n;

int main()
{
    cin >> n;
    for(int i = 1; i <= n; ++ i ) cin >> a[i];
    for(int i = 1; i <= n; ++ i ) cin >> b[i];
    for(int i = 1; i <= n; ++ i) {
        int maxv = 1;
        for(int j = 1; j <= n; ++ j) {
            f[i][j] = f[i - 1][j];
            if(a[i] == b[j]) f[i][j] = max(f[i][j], maxv);
            if(a[i] > b[j]) maxv = max(maxv, f[i - 1][j] + 1);
        }
    }
    int res = 0;
    for(int i = 1; i <= n; ++ i) res = max(res, f[n][i]);
    cout << res << "\n";
}

时间复杂度： $\mathcal{O(n^2)}$

例题1. 最长公共子序列(模板）

P1439
题意：
给出两个序列，均为 $\cdots n$ 的排列。求着两个序列的 $L C S$
$\le n \le 10^5$
solution：
如果利用前面 $\mathcal{O(n^2)}$ 的做法，显然是会TLE的。但我们换个思路去看，如果我去用第一个序列的顺序去映射第二个序列的。
举个例子：
5 3 4 1 2
3 4 5 2 1
这两个序列，用第一个序列去映射第二个序列后就变成了 2 3 1 5 4。然后你就会发现，只需要求这个序列的LIS就是这两个序列的LCS了。然后利用 $\mathcal{O(nlogn)}$ 的做法去求LIS
特别的，如果出现了重复元素，是否还存在 $\mathcal{O(nlogn)}$ 做法吗？（望大佬指教）
时间复杂度： $\mathcal{O(nlogn)}$
Code：

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5+10;
int dp[N];

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
	int n; cin >> n;
	vector<int>a(n), b(n);
	unordered_map<int,int>mp;
	for(int i = 0; i < n; ++i) cin >> a[i], mp[a[i]] = i;
	for(int i = 0; i < n; ++i) cin >> b[i];
	memset(dp, 0x3f, sizeof dp);
	int mx = dp[n];
	for(int i = 0; i < n; ++i)
		*upper_bound(dp, dp+n, mp[b[i]]) = mp[b[i]];
	int ans = 0;
	while( dp[ans] != mx) ans ++;
	cout << ans << endl; 	   
    return(0-0);
}

例题2. 合唱队形

Acwing 482

题意：
有 $N$ 个人，每个人有一个身高为 $a_i$ ，你需要找出最多的 $M$ 个人，使得 $a_1 > ··· a_i > a_{i+1} < ··· < a_M(1 \le i \le M)$

solution：
假设第 $i$ 个人为中心时的最优解。那么 $\sim a[i]$ 是一个上升严格的，并且 $\sim a[M]$ s是一个严格递减的。
所有我们预处理两个数组:

f[i]:表示 $\sim i$ 的最长上升子序列
g[i]：表示 $\sim n$ 的最长下降子序列

去枚举中心点，更新答案. $\le i \le n)$
时间复杂度： $\mathcal{O(n^2)}$ (ps：若采用上诉贪心可将复杂度降为 $\mathcal{O(nlogn)}$
code:

#include <bits/stdc++.h>
using namespace std;

const int N = 110;
int n;
int a[N], f[N], g[N];

int main()
{
    cin >> n;
    for(int i = 1; i <= n; ++ i)  cin >> a[i];
    for(int i = 1; i <= n; ++ i) {
        f[i] = 1;
        for(int j = 1; j < i; ++ j) 
            if(a[i] > a[j]) f[i] = max(f[i], f[j] + 1);
    }
    for(int i = n; i ; -- i) {
        g[i] = 1;
        for(int j = n; j > i; -- j)
            if(a[i] > a[j]) g[i] = max(g[i], g[j] + 1);
    }
    int res = 0;
    for(int i = 1; i <= n; ++ i) res = max(res, f[i] + g[i] - 1);
    cout << n - res << endl;
}

例题3. 友好城市

Acwing 1012

题意：
在南岸有 $N$ 座城市，分别有一个友好城市在北岸并且不同城市的友好城市不同。现在给出这 $N$ 座城市在南岸的位置，及他友好城市的位置。求能开辟多少个航线连接这些友好城市并且航线没有相交。

solution：
如果将这 $N$ 所城市从小到大去排序，那么为了不让航线有相交。那他的友好城市也一定是从小到大的顺序的。也就是先双关键字排序，然后后对第二关键字求LIS
时间复杂度： $\mathcal{O(n^2)}$ 同样的可将时间复杂度将为： $\mathcal{O(nlogn)}$
code：

#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII;
const int N = 5050;
PII a[N];
int n;
int f[N];
int main()
{
    scanf("%d", &n);
    for(int i = 1; i <= n; ++ i) scanf("%d%d", &a[i].first, &a[i].second);
    sort(a + 1, a + 1 + n);
    for(int i = 1; i <= n; ++ i) {
        f[i] = 1;
        for(int j = 1; j < i; ++ j)
            if(a[i].second > a[j].second) f[i] = max(f[i], f[j] + 1);
    }
    cout << *max_element(f + 1, f + 1 + n) << endl;
}

例题4. 导弹拦截

题目连接：Acwing 1010

题意：
有 $N$ 个导弹，高度分别为 $h_i$ ，导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。问该套拦截系统最多能拦截多少个导弹，需要多少套这个拦截系统才能全部拦下来

solution:
第一问：最多能拦截多少个导弹；因为第一发炮弹能打任意高度，且接下来的不能高于前一发的高度。就是求最长不上升子序列，很显然是一个求LIS的问题（将序列反过来）。用上述的 $\mathcal{O(nlogn)}$ 方法能够快速高效的解决
第二问：需要多少套能全部拦下来。也就是需要多少个最长不上升子序列覆盖整个序列。也就是最少的最长不上升子序列其实就是最长上升子序列
这是一个定理（qwq）：
Dilworth定理：对偏序集<A，≤>，设A中最长链的长度是n，则将A中元素分成不相交的反链，反链个数至少是n。

code：

#include <bits/stdc++.h>
using namespace std;
int main()
{
    vector<int> a, b;
    int x;
    while(cin >> x) a.push_back(x);
    int n = (int)a.size();
    for(int i = n - 1; i >= 0; -- i) b.push_back(a[i]);
    vector<int> dp(n + 10, 0x3f3f3f3f);
    for(int i = 0; i < n; ++ i)
        *upper_bound(dp.begin(), dp.end(), b[i]) = b[i];
    int mx = 0x3f3f3f3f; int cnt = 0;
    while(dp[cnt] != mx) ++ cnt;
    cout << cnt << endl;
    for(int i = 0; i <= n; ++i) dp[i] = 0x3f3f3f3f;
    for(int i = 0; i < n; ++i) 
        *lower_bound(dp.begin(), dp.end(), a[i]) = a[i];
    cnt = 0;
    while(dp[cnt] != mx) ++ cnt;
    cout << cnt << endl;
}

另外附上大佬的贪心解法：DP+贪心解法Orz

m元上升子序列

例题：UVA12983
题意：
有 $T$ 组数据，每组数据给出 $n ， m$ ，表示给出 $n$ 个数，求长度为 $m$ 的严格上升子序列。答案对 $1 e 9 + 7$ 取模
思路：
dp + 树状数组优化
定义： $d p [i] [j]$ 表示长度为 $i$ ，并且以 $a [j]$ 结尾的严格上升子序列的数量
状态转移： $\sum_{k<j,a[k] < a[j]} dp[i-1][k]$
优化：由于 $k < j$ ，将原数组离散化。在转移时，树状数组记录 $d p [i - 1] [j]$ 的答案，那么在求 $d p [i] [j]$ 的时候就是加上 $s u m (a [j] - 1)$

Code：

#include <bits/stdc++.h>
#define int long long
#define ALL(a) (a).begin(), (a).end()
using namespace std;
using LL = long long;
typedef pair<int, int> PII;
template < typename T> inline void Max(T &a, T b) { if(a < b) a = b; }
template < typename T> inline void Min(T &a, T b) { if(a > b) a = b; }
template < typename T>
struct BIT {
    const int n;
    vector<T> a;
    BIT(int n) : n(n) , a(n){}
    void add(int x, T v) {
        for (int i = x + 1; i <= n; i += i & -i) {
            a[i - 1] += v;
        }
    }
    T sum(int x) {
        T ans = 0;
        for (int i = x + 1; i > 0; i -= i & -i) {
            ans += a[i - 1];
        }
        return ans;
    }
    void rangeAdd(int l, int r, T v) {
        add(l, v);
        add(r, -v);
    }
    T rangeSum(int l, int r) {
        return sum(r) - sum(l);
    }
};
vector<int> alls;
int find(int x) {
    return lower_bound(ALL(alls), x) - alls.begin();
}
constexpr int mod = 1e9 + 7;
signed main() {
    cin.tie(nullptr) -> sync_with_stdio(false);
    int tt, cas = 1;
    cin >> tt;
    while (tt -- ) {
        alls.clear();
        int n, m;
        cin >> n >> m;
        vector<int> a(n);
        vector<vector<int>> dp(m + 1, vector<int> (n + 1, 0));
        for (int i = 0; i < n; ++ i) {
            cin >> a[i];
            alls.push_back(a[i]);
        }
        sort(ALL(alls));
        alls.erase(unique(ALL(alls)), alls.end());
        for (int i = 0; i < n; ++ i) dp[1][i] = 1, a[i] = find(a[i]);
        for (int i = 2; i <= m; ++ i) {
            BIT<int> bit(n);
            for (int j = 0; j < n; ++ j) {
                dp[i][j] = (dp[i][j] + bit.sum(a[j] - 1)) % mod;
                bit.add(a[j], dp[i - 1][j]);
            }
        }
        int ans = 0;
        for (int i = 0; i < n; ++ i) ans = (ans + dp[m][i]) % mod;
        cout << "Case " << "#" << cas ++ << ": " << ans << "\n";        
    }
    return 0;
}

W⁡angduoyu

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
【DP学习总结】LIS和LCS

文章目录最长公共子序列最长上升子序列最大上升子序列和例题1. 最长公共子序列(模板）题意：solution：Code：例题2. 合唱队形题意：solution：code:例题3. 友好城市题意：solution：code：例题4.最长公共子序列子序列允许不连续。定义：最长公共子序列，英文缩写为LCSLCSLCS（Longest Common Subsequence）。其定义是，一个序列 SSS ，如果分别是两个或多个已知序列的子序列，且是所有符合此条件序列中最长的，则 SSS 称为已知序列的最
复制链接

扫一扫