#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <cassert>
#include <deque>
#include <functional>
template <
class Container,
class T = typename Container::value_type,
class size_type = typename Container::size_type>
std::vector<T> sliding_max(const Container & input, size_type m) {
size_type input_size = input.size();
if (input_size < m)
return {};
std::vector<T> result;
size_t result_size = input_size - m + 1;
result.reserve(result_size);
struct QueueElem {
const T & value;
size_type index;
};
std::deque<QueueElem> queue;
auto input_it = input.begin();
for(size_type i = 0; i < m; ++i, ++input_it) {
QueueElem new_elem{*input_it, i};
while (!queue.empty() && queue.back().value <= new_elem.value)
queue.pop_back();
queue.push_back(new_elem);
}
result.push_back(queue.front().value);
for (size_type i = m; i < input_size; ++i, ++input_it) {
QueueElem new_elem{*input_it, i};
while (!queue.empty() && queue.back().value <= new_elem.value)
queue.pop_back();
queue.push_back(new_elem);
while (queue.front().index < i - m + 1)
queue.pop_front();
result.push_back(queue.front().value);
}
return result;
}
int main(){
std::vector<int> v = {3, 10, 11, 10, 0, 0, 0, 1, 2, 3, 2};
auto result_max = sliding_max(v, 3);
assert((result_max == decltype(result_max){11, 11, 11, 10, 0, 1, 2, 3, 3}));
return 0;
}
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