#include <iostream>
#include <queue>
#include <unordered_map>
#include <algorithm>
#include <stdlib.h>
typedef struct node{
int key;
int size;
struct node *left;
struct node *right;
}tree;
tree * insert(tree *root, int value){
if(root == NULL){
root = (tree *)malloc(sizeof(tree));
root->key = value;
root->left = root->right = 0;
root->size = 1;
return root;
}
root->size++;
if(value > root->key)
root->right = insert(root->right, value);
else
root->left = insert(root->left, value);
return root;
}
tree * os_select(tree *root, int i){
int r;
if (root->left)
r = root->left->size + 1;
else
r = 1;
if(i == r) return root;
else{
if(i < r) return os_select(root->left, i);
else return os_select(root->right, i - r);
}
}
void init_container(tree *container, const std::size_t n){
std::size_t weight;
for(std::size_t i = 0; i < n; i++){
std::cin >> weight;
container = insert(container, weight);
}
}
void init_warehouse(std::priority_queue<std::size_t> *wh, const std::size_t m){
std::size_t weight;
for(std::size_t i = 0; i < m; i++){
std::cin >> weight;
wh->push(weight);
}
}
void update_container(tree *container, std::priority_queue<std::size_t> warehouse){
if(!warehouse.empty()){
int piece_weight = warehouse.top();
warehouse.pop();
container = insert(container, piece_weight);
}
}
int main(){
std::size_t n, m, a, b, k;
register int x = 0;
std::priority_queue<std::size_t> warehouse;
tree *container = NULL;
tree *piece = NULL;
std::cin >> n; //N кусков в контейнере
std::cin >> m; //M кусков в хранилище
std::cin >> a;
std::cin >> b;
std::cin >> k; //K кусков, выданных покупателю
//Загружаем куски в соответствующие хранилища
init_container(*&container, n);
init_warehouse(&warehouse, m);
while(k--){
// Ищем кусок с номером x в порядке возрастания
piece = os_select(container, x);
std::cout << piece->key << " ";
update_container(*&container, warehouse);
}
}
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