题解 | #组建一支最强篮球队#

#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>

using namespace std;

// 检查字符串是否为有效的十进制整数
bool is_valid_integer(const string& s) {
    if (s.empty() || (s.length() > 1 && s[0] == '0') && s.find_first_not_of("0123456789") == string::npos) {
        // 允许单个'0', 但不允许'01'这样的前导零
        if (s.length() > 1 && s[0] == '0') return false;
    }
    if (s.length() == 1 && s[0] == '0') return true;
    
    // 检查是否有非数字字符，除了可能有的负号
    string temp = s;
    if (s[0] == '-') {
        temp = s.substr(1);
        if(temp.empty()) return false;
    }
    
    return temp.find_first_not_of("0123456789") == string::npos;
}

int main() {
    string line;
    if (!getline(cin, line)) {
        cout << "error" << endl;
        return 0;
    }

    stringstream ss(line);
    string score_str;
    vector<int> scores;
    while (ss >> score_str) {
        if (!is_valid_integer(score_str)) {
            cout << "error" << endl;
            return 0;
        }
        scores.push_back(stoi(score_str));
    }

    string k_str;
    if (!(cin >> k_str) || !is_valid_integer(k_str) || k_str[0] == '-') {
        cout << "error" << endl;
        return 0;
    }
    int k = stoi(k_str);

    if (k <= 0 || k > scores.size()) {
        // 虽然题目约束 k>0，但防御性编程处理
        return 0;
    }

    vector<int> stack;
    int n = scores.size();
    int removals = n - k;

    for (int score : scores) {
        while (!stack.empty() && score > stack.back() && removals > 0) {
            stack.pop_back();
            removals--;
        }
        stack.push_back(score);
    }
    
    // 如果淘汰名额没用完，栈中可能多于k个，截取前k个
    stack.resize(k);

    for (int i = 0; i < k; ++i) {
        cout << stack[i] << (i == k - 1 ? "" : " ");
    }
    cout << endl;

    return 0;
}

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        try {
            // 读取第一行球员评分
            String line = sc.nextLine();
            String[] score_strs = line.split(" ");
            List<Integer> scores = new ArrayList<>();
            for (String s : score_strs) {
                // 检查是否为有效十进制整数
                if (!s.matches("-?\\d+")) {
                    System.out.println("error");
                    return;
                }
                scores.add(Integer.parseInt(s));
            }

            // 读取第二行队伍人数
            int k = sc.nextInt();
            
            if (k <= 0 || k > scores.size()) {
                return; // 根据题目约束，k应为正数且不大于N
            }
            
            int n = scores.size();
            // 可以淘汰的人数
            int removals = n - k;
            
            // 使用 Deque 作为单调栈
            Deque<Integer> stack = new ArrayDeque<>();
            
            for (int score : scores) {
                // 当栈不为空，当前分数>栈顶，且还有淘汰名额时，淘汰栈顶
                while (!stack.isEmpty() && score > stack.peekLast() && removals > 0) {
                    stack.removeLast();
                    removals--;
                }
                stack.addLast(score);
            }
            
            // 最终结果为栈中的前 k 个元素
            StringBuilder sb = new StringBuilder();
            Iterator<Integer> it = stack.iterator();
            for (int i = 0; i < k; i++) {
                sb.append(it.next()).append(i == k - 1 ? "" : " ");
            }
            System.out.println(sb.toString());

        } catch (Exception e) {
            // 捕获所有可能的异常，如 NumberFormatException, NoSuchElementException 等
            System.out.println("error");
        }
    }
}

def solve():
    # 读取第一行并进行合法性校验
    try:
        score_strs = input().split()
        if not score_strs:
            print("error")
            return
        scores = [int(s) for s in score_strs]
    except ValueError:
        print("error")
        return
    
    # 读取第二行并进行合法性校验
    try:
        k_str = input()
        if not k_str.isdigit() or int(k_str) <= 0:
            print("error")
            return
        k = int(k_str)
    except (ValueError, IndexError):
        print("error")
        return

    n = len(scores)
    if k > n:
        return

    # 可淘汰的人数
    removals = n - k
    # 单调栈
    stack = []

    for score in scores:
        # 当栈不为空，当前分数大于栈顶，且还有淘汰名额
        while stack and score > stack[-1] and removals > 0:
            stack.pop()
            removals -= 1
        stack.append(score)
    
    # 截取前 k 个元素作为结果
    result = stack[:k]
    
    # 格式化输出
    print(*result)

solve()