题目名称：偶数单增序列 题目描述 描述 给定一个长度为 N（不大于500）的整数序列， 请将其中的所有偶数取出，并按升序输出。 测试数据保证至少有一个偶数。 输入 共2行： 第1行为 N； 第2行为 N 个整数，其间用空格间隔。 输出 输出升序的偶数序列，数据之间以 逗号 间隔。 输入 10 1 3 2 6 5 4 9 8 7 10 输出 2,4,6,8,10 c++代码

以下是 C++ 代码实现：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    int n;
    cin >> n;
    vector<int> nums(n);
    for (int i = 0; i < n; i++) {
        cin >> nums[i];
    }
    vector<int> evens;
    for (int num : nums) {
        if (num % 2 == 0) {
            evens.push_back(num);
        }
    }
    sort(evens.begin(), evens.end());
    for (int i = 0; i < evens.size(); i++) {
        cout << evens[i];
        if (i < evens.size() - 1) {
            cout << ",";
        }
    }
    cout << endl;
    return 0;
}

思路：

首先读入整数序列，然后遍历序列，将偶数存入一个新的 vector 中。接着对这个 vector 进行排序，最后输出排序后的偶数序列，并在数字之间添加逗号。

相关问题

1177：奇数单增序列

1177的奇数单增序列是指在给定的序列中，只输出奇数，并且按照递增的顺序排列。根据给定的引用和，我们可以使用插入排序或冒泡排序来实现这个功能。下面是使用插入排序的示例代码：

#include<iostream>
using namespace std;

void insertsort(int *arr, int *y);//插入排序函数

int main() {
    int n, m=1, num;
    cin>>n;
    int a[n];
    for(int i=0; i<n; i++) {
        cin>>num;
        if((num%2)!=0) {//存储奇数
            a[m]=num;
            m++;//记录有效数组长度
        }
    }
    insertsort(a, &m);//调用插入排序函数
    cout<<a = arr[i];//arr是哨兵
        for(j=i-1; arr[j]>arr = arr[j];//后移
        }
        if(j!=i-1) arr[j+1 = arr

给定一个序列,求最少去掉多少个数,使得剩下的数满足先单增后单减

这是一个经典的动态规划问题，可以使用两个数组分别记录以每个位置结尾的单增子序列的长度和以每个位置开始的单减子序列的长度。具体的，设 $dp1[i]$ 表示以 $i$ 结尾的单增子序列的最大长度，$dp2[j]$ 表示以 $j$ 开始的单减子序列的最大长度，则有：

$$
dp1[i]=\max_{0\le j<i,\,a_j<a_i}\{dp1[j]\}+1
$$

$$
dp2[j]=\max_{i\le k\le n,\,a_j>a_k}\{dp2[k]\}+1
$$

其中 $a_i$ 表示给定的序列中第 $i$ 个数。最终答案为 $\max_{i=1}^n\{dp1[i]+dp2[i]-1\}$，即单增子序列的最大长度加单减子序列的最大长度再减去1。

以下是 Python 代码实现：

def min_remove(nums):
    n = len(nums)
    dp1 = [1] * n
    dp2 = [1] * n
    for i in range(1, n):
        for j in range(i):
            if nums[j] < nums[i]:
                dp1[i] = max(dp1[i], dp1[j] + 1)
        for j in range(n - 1, i - 1, -1):
            if nums[j] < nums[i]:
                dp2[i] = max(dp2[i], dp2[j] + 1)
    res = 0
    for i in range(n):
        res = max(res, dp1[i] + dp2[i] - 1)
    return n - res

时间复杂度为 $O(n^2)$，可以通过一些优化降低时间复杂度，比如使用二分查找来加速寻找前面的最大值，这里不再赘述。