#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;
}