最大递增子序列

HJ24 合唱队

描述

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

设KK位同学从左到右依次编号为 1，2…，K ，他们的身高分别为T_1,T_2,…,T_KT1​,T2​,…,TK​ ，若存在i(1\leq i\leq K)i(1≤i≤K) 使得T_1<T_2<......<T_{i-1}<T_iT1​<T2​<......<Ti−1​<Ti​ 且 T_i>T_{i+1}>......>T_KTi​>Ti+1​>......>TK​，则称这KK名同学排成了合唱队形。

通俗来说，能找到一个同学，他的两边的同学身高都依次严格降低的队形就是合唱队形。

例子： 

123 124 125 123 121 是一个合唱队形

123 123 124 122不是合唱队形，因为前两名同学身高相等，不符合要求

123 122 121 122不是合唱队形，因为找不到一个同学，他的两侧同学身高递减。

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

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

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

输入描述：

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

输出描述：

最少需要几位同学出列

示例1

输入：

8
186 186 150 200 160 130 197 200

复制输出：

4

复制说明：

由于不允许改变队列元素的先后顺序，所以最终剩下的队列应该为186 200 160 130或150 200 160 130          

解题思路：

正常情况下求最大递增子序列长度，可以维护一个递增子序列数组，拿外部元素去子序列数组中进行比较和填充，最终数组的大小就是最大递增子序列的长度。但是这一题并不是要单纯的求最大递增子序列，而是要求以C位同学为中心，即C位同学必须是递增子序列的最大值，和递减子序列的最大值。

所以按照题目要求，计算以每位同学为终点的最大递增子序列长度（即左侧），和以其为起点的最大递减子序列长度（即右侧），其二者之和最大的同学，就可以站在C位。

小技巧：递减子序列，就是逆向的递增子序列。以某个节点为起点的递减子序列，反过来看就是以它为终点的递增子序列。

时间复杂度：O( N * log N)

代码：

#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#include<string.h>
#include<map>
#include<set>
#include<math.h>
#include <algorithm>
#include<sstream>

using namespace std;

//二分查找，升序序列
int binary_search(vector<int> &vec, int target)
{
    int begin = 0;
    int end = vec.size() - 1;
    int mid;
    while(begin <= end)
    {
        mid =(begin + end) / 2;
        if(vec[mid] < target)
        {
            begin = mid + 1;
        }
        else if(vec[mid] > target)
        {
            end = mid - 1;
        }
        else
        {
            return mid;
        }
    }
    
    return begin;
}

//计算target为终点的最长递增子序列
int max_increase_len(vector<int> &vec, int target)
{
    int pos = binary_search(vec, target);
    if(pos == vec.size())
    {
        vec.push_back(target);
    }
    else
    {
        vec[pos] = target;
    }
    
    return pos + 1;
}

int main(void)
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    
    int num;
    cin >> num;
    vector<int> vec;
    while(num--)
    {
        int high;
        cin >> high;
        vec.push_back(high);
    }
    
    //递增/递减序列中间状态数组
    vector<int> increase_vec;
    vector<int> decrease_vec;
    
    //以i为终点的的递增子序列最大长度结果保存数组
    vector<int> increase_len_vec(vec.size(), 0);
    //以i为起点的的递减子序列最大长度结果保存数组
    vector<int> decrease_len_vec(vec.size(), 0);
    
    for(int i = 0; i < vec.size(); i++)
    {
        //求以当前元素为终点的最长递增子序列的长度
        int increase_len = max_increase_len(increase_vec, vec[i]);
        increase_len_vec[i] = increase_len;
    }
    
    //逆向的递增序列，就是正向的递减序列
    for(int i = vec.size() - 1; i >= 0; i--)
    {
        //计算以当前节点为起始点的最长递减子序列的长度
        int decrease_len = max_increase_len(decrease_vec, vec[i]);
        decrease_len_vec[i] = decrease_len;
    }
    
    int max_len = 0;
    
    //在结果集中，查询最大的二者之和
    for(int i = 0; i < vec.size(); i++)
    {
        //当前节点在两个结果中各自被被包含了1次，需要减1
        int curr_len = increase_len_vec[i] + decrease_len_vec[i] - 1;
        if(max_len < curr_len)
        {
            max_len = curr_len;
        }
    }

    cout << vec.size() - max_len << endl;
    
    return 0;
}