dp14-17最长上升子序列——原题+变式

dp 14 最长上升子序列(一)

题目描述

描述

给定一个长度为 n 的数组 arr，求它的最长严格上升子序列的长度。

所谓子序列，指一个数组删掉一些数（也可以不删）之后，形成的新数组。例如 [1,5,3,7,3] 数组，其子序列有：[1,3,3]、[7] 等。但 [1,6]、[1,3,5] 则不是它的子序列。

我们定义一个序列是 严格上升 的，当且仅当该序列不存在两个下标 ii 和 jj 满足 i<ji<j 且 arr_i \geq arr_jarr**i≥arr**j。

数据范围：
$$0\le n\le 1000,|ar{r}_i|\le 10^9$$
要求：时间复杂度 O(n^2) O(n2)， 空间复杂度 O(n)O(n)

输入描述：

第一行输入一个正整数 n ，表示数组的长度

第二行输入 n 个整数表示数组的每个元素。

输出描述：

输出最长严格上升子序列的长度

输入样例
7
6 3 1 5 2 3 7
输出
4

leetcode版本描述

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。
输入：nums = [7,7,7,7,7,7,7]
输出：1

思路分析：

此题为标准的线性动态规划题目。首先考虑状态如何定义。如果定义为前 i 个元素中最长的严格上升子序列的长度，那么我们将无法利用已记录的值，因为它只说明是最长的长度。但是它没有说明这个序列是怎么开始的，又是怎么结束的。我们无法给它进行具体的判断，这个序列的其他信息我们并没有记录。

所以在这里我们可以给 状态再加一个限制，即以前 i 个以 第 i 个元素结尾的最长的严格上升子序列的长度。这样加完后，每当我们读入一个新的元素，我们就可以去查找之前的dp数组，找到 这个新的元素可以被添加到哪个序列后，统计最大值。自底向上的就能计算所有值。

至于剩下的拦截导弹，很明显就是这题从递增变递减，再多计算一个最少个数就行。

合唱队形，就是双向的最长上升子序列，然后统计人数，得到k，减掉就行了。

信封嵌套则是二维的最长上升子序列，排序后再计算即可。
(最长上升子序列还可以贪心加二分，这里只给出了dp解法)

具体代码实现：

/*dp14*/
#include <bits/stdc++.h>
using namespace std;
    int n;
    int a[1001];
    int dp[1001];
    //定义dp(i) 为 前i个元素中 以第i个元素结尾的序列的 最长严格上升子序列的长度
    //这样的话 每次后续新增加一个元素 能够去增加答案的长度
int main() {
    scanf("%d", &n);
    for(int i = 0; i < n; ++i) {
        scanf("%d", &a[i]);
    }
    int maxN = INT_MIN;
    for(int i = 0; i < n; ++i) dp[i] = 1;
    for(int i = 1; i < n; ++i) {
        for(int j = 0; j < i; ++j) {
            if(a[i] > a[j]) {
                dp[i] = max(dp[i], dp[j]+1);
            }
        }
        maxN = max(maxN, dp[i]);
    }
    // for(int i = 0; i < n; ++i) {
    //     printf("%d", dp[i]);
    // }
    //cout << endl;
    printf("%d", maxN);
    return 0;
}

dp 15 拦截导弹

/*dp15*/
//最长上升/下降子序列 + 序列数
#include <bits/stdc++.h>
using namespace std;
    int n;
    int a[1001];
    int dp[1001];
    //定义dp(i) 为 前i个元素中 以第i个元素结尾的序列的 最长严格上升子序列的长度
    //这样的话 每次后续新增加一个元素 能够去增加答案的长度
int main() {
    scanf("%d", &n);
    for(int i = 0; i < n; ++i) {
        scanf("%d", &a[i]);
    }
    int maxN = INT_MIN;
    int c = 1;

    vector<int> s;
    s.push_back(a[0]);
    vector<int>::iterator it;
    for(int i = 0; i < n; ++i) dp[i] = 1;
    for(int i = 1; i < n; ++i) {
        it = lower_bound(s.begin(), s.end(), a[i]);//注意这里 必须是lower_bound 这样才能算上刚好等于a[i]的元素
        if(it == s.end()) {//新值 添加
            s.push_back(a[i]);
        } else { // 小于的时候 更新当前的值 
            *it = a[i];
        }
        for(int j = 0; j < i; ++j) {
            if(a[i] <= a[j]) {
                dp[i] = max(dp[i], dp[j]+1);
            }
        }
        maxN = max(maxN, dp[i]);
    }
    //  for(int i = 0; i < n; ++i) {
    //      printf("%d", dp[i]);
     // }
    //cout << endl;
    // for(int v : s) {
    //     cout << v << ' ';
    // }
    // cout << endl;
    printf("%d\n%d", maxN, s.size());
    return 0;
}

dp 16 合唱队形

/*dp16*/
//最长上升子序列 * 2
#include <cstdio>
#include <iostream>

int max(int x, int y) {
    if(x < y) return y;
    return x;
} 
    int n;
    int a[1001];
    
    int left[1001];
    int right[1001];
    //定义dp(i) 为 前i个元素中 以第i个元素结尾的序列的 最长严格上升子序列的长度
    //这样的话 每次后续新增加一个元素 能够去增加答案的长度
int main() {
    scanf("%d", &n);
    for(int i = 0; i < n; ++i) {
        scanf("%d", &a[i]);
    }
    for(int i = 0; i < n; ++i) 
        left[i] = right[i] = 1;
    for(int i = 1; i < n; ++i) {
        for(int j = 0; j < i; ++j) {
            if(a[i] > a[j]) {
                left[i] = max(left[i], left[j]+1);
            }
        }
    }
    for(int i = n-1; i >= 0; --i) {
        for(int j = n-1; j > i; --j) {
            if(a[i] > a[j]) {
                right[i] = max(right[i], right[j]+1);
            }
        }
    }

    // for(int i = 0; i < n; ++i) {
    //     std::cout << left[i] << ' ';
    // }
    // std::cout << std::endl;
    // for(int i = 0; i < n; ++i) {
    //     std::cout << right[i] << ' ';
    // }
    int maxN = 0;
    for(int i = 0; i < n; ++i) {
        maxN = max(maxN, left[i] + right[i]);
    }
    printf("%d", n - maxN + 1);
    return 0;
}

dp 17 信封嵌套

/*dp17信封嵌套*/
#include <bits/stdc++.h>
using namespace std;
int n;
int dp[1001];
bool cmp(const pair<int, int>& x, const pair<int, int>& y) {
    if (x.first != y.first) {
        return x.second < y.second;
    }
    return x.first < y.first;
}
int main() {
    scanf("%d", &n);
    vector<pair<int, int> > a(n, pair<int, int>(0, 0));
    for (int i = 0; i < n; ++i) {
        scanf("%d %d", &a[i].first, &a[i].second);
    }
    sort(a.begin(), a.end(), cmp);
    
    int maxN = 1;
    for (int i = 0; i < n; ++i) dp[i] = 1;
    for (int i = 1; i < n; ++i) {
        for (int j = 0; j < i; ++j) {
            if (a[i].first > a[j].first && a[i].second > a[j].second) {
                dp[i] = max(dp[i], dp[j] + 1);
            }
        }
        maxN = max(maxN, dp[i]);
    }
    // for(int i = 0; i < n; ++i) {
    //     printf("%d", dp[i]);
    // }
    //cout << endl;
    printf("%d\n", maxN);
    return 0;
}

/*dp17 信封嵌套 二分 排序方式类似于leetcode-757. 设置交集大小至少为2*/
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 200010;
int endsArr[N];

struct Letter {
    int height, width;
    bool operator < (const Letter& L) const {
        return height != L.height ? height < L.height: width > L.width;
    }
    int main() {
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        int h, w;
        scanf("%d%d", &h, &w);
        letters[i] = {h, w};
    }
    if (n == 1) {
        cout << 1 << endl;
        return 0;
    }
    sort(letters, letters + n);
//     for(int i = 0; i < n; i++) cout << letters[i].height << " " << letters[i].width << endl;
    endsArr[0] = letters[0].width;
    int size = 0;
    for (int i = 1; i < n; i++) {
        int index = lower_bound(endsArr, endsArr + size + 1,
                                letters[i].width) - endsArr;
        if (index == size + 1) {
            size++;
        }
        endsArr[index] = letters[i].width;
    }
    printf("%d\n", size + 1);
    return 0;
}