ACM. HJ24 合唱队 ●●

HJ24 合唱队 ●●

描述

N 位同学站成一排，音乐老师要请最少的同学出列，使得剩下的 K 位同学排成合唱队形。

设K位同学从左到右依次编号为 1，2…，K ，他们的身高分别为 $T_k$，能找到一个同学，他的两边的同学身高都依次严格降低的队形就是合唱队形。

例子：
123 124 125 123 121 是一个合唱队形
123 123 124 122不是合唱队形，因为前两名同学身高相等，不符合要求
123 122 121 122不是合唱队形，因为找不到一个同学，他的两侧同学身高递减。

你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。

注意：不允许改变队列元素的先后顺序 且 不要求最高同学左右人数必须相等

数据范围： $1\le n\le 3000$

输入描述：

用例两行数据，第一行是同学的总数 N ，第二行是 N 位同学的身高，以空格隔开

输出描述：

最少需要几位同学出列

示例

输入：
8
186 186 150 200 160 130 197 200
输出：
4
说明：
由于不允许改变队列元素的先后顺序，所以最终剩下的队列应该为186 200 160 130或150 200 160 130

题解

1. 动态规划（最长递增子序列）

为了得到最少的出列人数，那么我们可以计算出当以某个身高为中点时，他左右两边符合条件的最大人数和，总人数减去合唱队列人数即为最终结果。

因此，我们可以用两个数组 left、right，记录某个身高为终点、起点时的最长递增 / 递减子序列和。

如此，便可以将问题转化为与300. 最长递增子序列 ●●类似的情况。

• 时间复杂度：$O(n^2)$，需要多次遍历数组，两层for循环嵌套。
• 空间复杂度：$O(n)$，存每个位置的dp递增和递减数组。

#include <iostream>
#include <vector>
using namespace std;

int main(){
    int n;
    cin >> n;
    vector<int> statures(n, 0);
    for(int i = 0; i < n; ++i){
        cin >> statures[i];
    }
    vector<int> left(n, 0);
    vector<int> right(n, 0);
    for(int i = 0; i < n; ++i){
        for(int j = i-1; j >= 0; --j){
            if(statures[i] > statures[j]){
                left[i] = max(left[i], left[j] + 1);	// staturs[i]前的最长递增子序列
            }
        }
    }
    for(int i = n-1; i >= 0; --i){
        for(int j = i+1; j < n; ++j){
            if(statures[i] > statures[j]){
                right[i] = max(right[i], right[j] + 1);	// staturs[i]后的最长递减子序列
            }
        }
    }
    int ans = 0;
    for(int i = 0; i < n; ++i){							// 计算比较结果
        ans = max(ans, (left[i]+right[i]+1) * (left[i]>0 && right[i]>0));
    }
    cout << n-ans;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

2. 动态规划 + 二分法

利用一个动态数组记录当前的序列，并用二分法进行插入排序，来得到最长子序列的长度，具体见300. 最长递增子序列 ●●

• 时间复杂度：$O(nlo{g}_2(n))$，借助二分。
• 空间复杂度：$O(n)$，一个存左右子序列值的数组。

#include <iostream>
#include <vector>
using namespace std;

int main(){
    int n;
    cin >> n;
    vector<int> statures(n, 0);
    for(int i = 0; i < n; ++i){
        cin >> statures[i];
    }
    vector<int> left(n, 1);					// left表示staturs[i]结尾的最长递增子序列长度
    vector<int> dpl;
    dpl.emplace_back(statures[0]);			// 动态规划数组
    for(int i = 1; i < n; ++i){
        if(statures[i] > dpl[dpl.size()-1]){
            dpl.emplace_back(statures[i]);
            left[i] = dpl.size();
            continue;
        }
        int l = 0, r = dpl.size()-1;
        while(l <= r){
            int mid = (l+r) >> 1;
            if(dpl[mid] >= statures[i]){
                r = mid - 1;
            }else{
                l = mid + 1;
            }
        }
        dpl[l] = statures[i];			// 替换位置
        left[i] = l + 1;				// 这里要更新staturs[i]对应的子序列长度，即l+1
    }
    vector<int> right(n, 1);			// right表示staturs[i]开头的最长递减子序列长度
    vector<int> dpr;
    dpr.emplace_back(statures[n-1]);	// 动态规划数组
    for(int i = n-2; i >= 0; --i){
        if(statures[i] > dpr[dpr.size()-1]){
            dpr.emplace_back(statures[i]);
            right[i] = dpr.size();
            continue;
        }
        int l = 0, r = dpr.size()-1;
        while(l <= r){
            int mid = (l+r) >> 1;
            if(dpr[mid] >= statures[i]){
                r = mid - 1;
            }else{
                l = mid + 1;
            }
        }
        dpr[l] = statures[i];
        right[i] = l + 1;				// 这里要更新staturs[i]对应的子序列长度，即l+1
    }
    int ans = 0;
    for(int i = 0; i < n; ++i){			// 所有身高为中点时的队列长度和
        ans = max(ans, (left[i]+right[i]-1) * (left[i]>0 && right[i]>0));
    }
    cout << n-ans;						// 出列人数
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60