线段树优化最长上升子序列问题

最长上升子序列

给定一个长度为 $N$ 的数列，求数值严格单调递增的子序列的长度最长是多少。

输入格式

第一行包含整数 $N$。

第二行包含 $N$ 个整数，表示完整序列。

输出格式

输出一个整数，表示最大长度。

数据范围

$1 \leq N \leq 1000$，
${−10}^{9} \leq \text{数列中的数} \leq {10}^{9}$

输入样例：

7
3 1 2 1 8 5 6

输出样例：

4

 

解题思路

　　首先这是最基本的最长上升子序列问题，常规解法是动态规划，时间复杂度为$O(n^2)$。

　　定义状态$f(i)$表示所有以第$i$个数结尾的严格递增的序列，属性是最大值。现在序列的最后一个数已经确定了（就是第$i$个数），因此可以根据序列的倒数第二个数来进行集合的划分，状态转移方程为$$f(i) = \max_{1 \leq j < i}\{ {f(j)+1} \}$$

　　当然$j$要满足$a[j] < a[i]$，$a[i]$表示第$i$个位置上的数。同时还需要注意到如果以第$i$个数结尾的序列长度为$1$，也就是只选择$a[i]$这个数（没有倒数第二个数），此时应该有$f(i)=1$，因此枚举到$i$时需要进行初始化$f(i)=1$（理解为没有倒数第二数的情况）。

　　AC代码如下：

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

const int N = 1010;

int a[N];
int f[N];

int main() {
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%d", a + i);
    }
    
    int ret = 0;
    for (int i = 1; i <= n; i++) {
        f[i] = 1;   // 序列中只有a[i]这个数
        for (int j = 1; j < i; j++) {
            if (a[j] < a[i]) f[i] = max(f[i], f[j] + 1);    // 要满足a[j]<a[i]才可以接到a[i]的后面
        }
        ret = max(ret, f[i]);
    }
    
    printf("%d", ret);
    
    return 0;
}

　　如果$n$扩大到${10}^{5}$，很明显上面的做法肯定是会超时的，下面讲如何用线段树来优化。

 

最长上升子序列 II

给定一个长度为 $N$ 的数列，求数值严格单调递增的子序列的长度最长是多少。

输入格式

第一行包含整数 $N$。

第二行包含 $N$ 个整数，表示完整序列。

输出格式

输出一个整数，表示最大长度。

数据范围

$1 \leq N \leq 100000$，
${−10}^{9} \leq \text{数列中的数} \leq {10}^{9}$

输入样例：

7
3 1 2 1 8 5 6

输出样例：

4

 

解题思路

　　好吧其实题面和上一题完全是一样的，就是$N$的数据范围扩大到${10}^5$。

　　做法其实有两种，一种是贪心加二分，时间复杂度可以做到$O(n \log n)$。另外一种还是动态规划，不过要用线段树来优化，时间复杂度也是$O(n \log n)$，这里主要是讲如何用线段树来优化的（另外一种做法有空再写，挖个坑先）。

　　这里的状态定义就和前面的不一样了。定义状态$f(i)$表示所有以数值$i$为结尾的严格递增的序列，属性是最大值。这里的$i$不是指第$i$个数，而是一个明确的值（即某个位置上的数值）。一样根据序列倒数第二个数值的不同来划分集合，因此状态转移为$$f(i) = \max_{1 \leq j < i}\{ {f(j)+1} \}$$

　　看上去好像跟第一题那个状态转移方程一样，但要明确的是第一题的$i,j$是指数的下标，而这一题的$i,j$是指数值的大小。

　　可以发现每次更新状态时，就是求一个区间的最值（等号右边），以及进行单点修改（等号左边），因此可以想到用线段树来维护。

　　线段树维护的是状态数组$f$各个区间的最值。一开始初始化线段树的时候有$f[i]$为$0$，因为此时还没有任何一个数构成序列，对应的线段树所维护的各个区间的最值为$0$。

　　还没有完，注意到数的取值范围是$\left[ {{−10}^{9}, {10}^{9}} \right]$，因此需要进行离散化。

　　AC代码如下：

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

const int N = 1e5 + 10;

struct Node {
    int l, r, maxv;
}tr[N * 4];
int a[N];
int xs[N], sz;

int find(int x) {
    int l = 1, r = sz;
    while (l < r) {
        int mid = l + r >> 1;
        if (xs[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return l;
}

void build(int u, int l, int r) {
    if (l == r) {
        tr[u] = {l, r, 0};  // 初始化各个区间的最值为0
    }
    else {
        int mid = l + r >> 1;
        build(u << 1, l, mid);
        build(u << 1 | 1, mid + 1, r);
        tr[u] = {l, r, 0};
    }
}

void modify(int u, int x, int c) {
    if (tr[u].l == x && tr[u].r == x) {
        tr[u].maxv = c;
    }
    else {
        if (x <= tr[u].l + tr[u].r >> 1) modify(u << 1, x, c);
        else modify(u << 1 | 1, x, c);
        tr[u].maxv = max(tr[u << 1].maxv, tr[u << 1 | 1].maxv);
    }
}

int query(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].maxv;
    int mid = tr[u].l + tr[u].r >> 1, maxv = 0;
    if (l <= mid) maxv = query(u << 1, l, r);
    if (r >= mid + 1) maxv = max(maxv, query(u << 1 | 1, l, r));
    return maxv;
}

int main() {
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%d", a + i);
        xs[++sz] = a[i];
    }
    
    // 离散化
    sort(xs + 1, xs + sz + 1);
    sz = unique(xs + 1, xs + sz + 1) - xs - 1;
    
    build(1, 1, sz);
    
    for (int i = 1; i <= n; i++) {
        int x = find(a[i]); // a[i]映射到值x
        // 查询f[1]~f[x-1]的最值，同时修改f[x]的值
        modify(1, x, query(1, 1, x - 1) + 1);
        // 可以分开写成
        // int t = query(1, 1, x - 1);
        // modify(1, x, t + 1);
    }
    
    printf("%d", tr[1].maxv);   // 枚举f[1~sz]的最值，可以发现tr[1]就维护了1~sz的最值
    
    return 0;
}

　　2023-02-10补充更新。

　　其实用原始的状态定义也是可以的，我更推荐这样理解。

　　一样的，定义状态$f(i)$表示所有以第$i$个数结尾的严格递增的序列的最大长度。然后状态转移本质就是在前$i$个数中找出来所有满足$a_j < a_i$的$j$，然后在这些$j$中找到一个最大的$f(j)$。因此我们可以开个线段树来维护所有的$a_j$，在$a_j$处记录的值是$f(j)$，然后在$1 \sim a_i - 1$这个前缀中找到最大的$f(j)$。

　　AC代码如下：

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

const int N = 1e5 + 10;

int a[N];
int f[N];
int xs[N], sz;
struct Node {
    int l, r, maxv;
}tr[N * 4];

int find(int x) {
    int l = 1, r = sz;
    while (l < r) {
        int mid = l + r >> 1;
        if (xs[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return l;
}

void build(int u, int l, int r) {
    if (l == r) {
        tr[u] = {l, r, 0};
    }
    else {
        int mid = l + r >> 1;
        build(u << 1, l, mid);
        build(u << 1 | 1, mid + 1, r);
        tr[u] = {l, r, 0};
    }
}

void modify(int u, int x, int c) {
    if (tr[u].l == tr[u].r) {
        tr[u].maxv = c;
    }
    else {
        if (x <= tr[u].l + tr[u].r >> 1) modify(u << 1, x, c);
        else modify(u << 1 | 1, x, c);
        tr[u].maxv = max(tr[u << 1].maxv, tr[u << 1 | 1].maxv);
    }
}

int query(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].maxv;
    int mid = tr[u].l + tr[u].r >> 1, maxv = 0;
    if (l <= mid) maxv = query(u << 1, l, r);
    if (r >= mid + 1) maxv = max(maxv, query(u << 1 | 1, l, r));
    return maxv;
}

int main() {
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%d", a + i);
        xs[++sz] = a[i];
    }
    sort(xs + 1, xs + sz + 1);
    sz = unique(xs + 1, xs + sz + 1) - xs - 1;
    build(1, 1, sz);
    for (int i = 1; i <= n; i++) {
        int x = find(a[i]);
        f[i] = query(1, 1, x - 1) + 1;
        modify(1, x, f[i]);
    }
    printf("%d", *max_element(f + 1, f + n + 1));
    
    return 0;
}

　　另外，求前缀最大值也可以用树状数组来实现，AC代码如下：

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

const int N = 1e5 + 10;

int a[N];
int xs[N], sz;
int f[N];
int tr[N];

int find(int x) {
    int l = 1, r = sz;
    while (l < r) {
        int mid = l + r >> 1;
        if (xs[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return l;
}

int lowbit(int x) {
    return x & -x;
}

void add(int x, int c) {
    for (int i = x; i <= sz; i += lowbit(i)) {
        tr[i] = max(tr[i], c);
    }
}

int query(int x) {
    int ret = 0;
    for (int i = x; i; i -= lowbit(i)) {
        ret = max(ret, tr[i]);
    }
    return ret;
}

int main() {
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%d", a + i);
        xs[++sz] = a[i];
    }
    sort(xs + 1, xs + sz + 1);
    sz = unique(xs + 1, xs + sz + 1) - xs - 1;
    for (int i = 1; i <= n; i++) {
        int x = find(a[i]);
        f[i] = query(x - 1) + 1;
        add(x, f[i]);
    }
    printf("%d", *max_element(f + 1, f + n + 1));
    
    return 0;
}

 

Longest Increasing Subsequence II

You are given an integer array nums and an integer k .

Find the longest subsequence of nums that meets the following requirements:

• The subsequence is strictly increasing and
• The difference between adjacent elements in the subsequence is at most k .

Return the length of the longest subsequence that meets the requirements.

A subsequence is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.

Example 1:

Input: nums = [4,2,1,4,3,4,5,8,15], k = 3
Output: 5
Explanation:
The longest subsequence that meets the requirements is [1,3,4,5,8].
The subsequence has a length of 5, so we return 5.
Note that the subsequence [1,3,4,5,8,15] does not meet the requirements because 15 - 8 = 7 is larger than 3.

Example 2:

Input: nums = [7,4,5,1,8,12,4,7], k = 5
Output: 4
Explanation:
The longest subsequence that meets the requirements is [4,5,8,12].
The subsequence has a length of 4, so we return 4.

Example 3:

Input: nums = [1,5], k = 1
Output: 1
Explanation:
The longest subsequence that meets the requirements is [1].
The subsequence has a length of 1, so we return 1.

Constraints:

$1 \leq nums.length \leq {10}^{5}$
$1 \leq {nums[i], k} \leq {10}^{5}$

 

解题思路

　　可以发现就是上一题的扩展，序列不仅要保证严格单调递增，同时还有满足任意两个相邻的数的差不超过$k$。做法和上面那题几乎一样，不过由于数值的取值范围很小，因此不需要进行离散化。

　　状态定义$f(i)$与上一题一样，表示所有以数值$i$为结尾的严格递增的序列，属性是最大值。状态转移方程就变成了$$f(i) = \max_{i - k \leq j \leq i - 1}\{ {f(j)+1} \}$$

　　比赛的时候一直想着最原始的最长上升子序列问题的状态定义（即第一题的状态定义），结果用贪心加二分的做法一直没写出来，实在是没想到会用这种方式来定义状态。

　　AC代码如下：

const int N = 1e5 + 10;

class Solution {
public:
    struct Node {
        int l, r, maxv;
    }tr[N * 4];

    void build(int u, int l, int r) {
        if (l == r) {
            tr[u] = {l, r, 0};
        }
        else {
            int mid = l + r >> 1;
            build(u << 1, l, mid);
            build(u << 1 | 1, mid + 1, r);
            tr[u] = {l, r, 0};
        }
    }

    void modify(int u, int x, int c) {
        if (tr[u].l == x && tr[u].r == x) {
            tr[u].maxv = c;
        }
        else {
            if (x <= tr[u].l + tr[u].r >> 1) modify(u << 1, x, c);
            else modify(u << 1 | 1, x, c);
            tr[u].maxv = max(tr[u << 1].maxv, tr[u << 1 | 1].maxv);
        }
    }

    int query(int u, int l, int r) {
        if (tr[u].l >= l && tr[u].r <= r) return tr[u].maxv;
        int mid = tr[u].l + tr[u].r >> 1, maxv = 0;
        if (l <= mid) maxv = query(u << 1, l, r);
        if (r >= mid + 1) maxv = max(maxv, query(u << 1 | 1, l, r));
        return maxv;
    }

    int lengthOfLIS(vector<int>& nums, int k) {
        build(1, 1, N - 1);
        for (int &it : nums) {
            modify(1, it, query(1, max(1, it - k), it - 1) + 1);
        }
        return tr[1].maxv;
    }
};

 

参考资料

　　【力扣周赛 310】最长上升子序列+线段树优化DP | LeetCode 算法刷题：https://www.bilibili.com/video/BV1it4y1L7kL