#include <cmath>
#include <map>
#include <string>
#include <algorithm>
#include <iostream>
#include <set>
#include <utility>
#include <vector>
#include <numeric>
#include <chrono>
#include <type_traits>
#include <cassert>
#include <sstream>
#include <unordered_map>
#include <stdexcept>
#include <stack>
#include <iterator>
using namespace std;

template <typename Type>
ostream &operator<<(ostream &out, const pair<Type,Type> &range){
    return out << range.first /*<< " "s*/ /*<< range.second << endl*/;
}

template <typename It>
void PrintRange(It range_begin, It range_end){
    for(auto it = range_begin; it != range_end; ++it){
        cout << *it << " "s;
    }
    cout << endl;
}

template <typename Type>
class Stack{
public:
    void Push(const Type &element){ //Вставка элемента в стек
        elements_.push_back(element);
    }
    void Pop(){ //Удаление элемента из стека
        elements_.pop_back();
    }
    const Type &Peek() const{ //Получение значения вершины стека
        /*const Type type;
        for(size_t i = 0; i < elements_.size(); ++i){
            if(elements_.at(i) == elements_.size() - 1){
                type = elements_.at(i);
            }
        }
        return type;*/
        //return elements_[static_cast<int>(elements_.size()) - 1];
        return elements_.back();
    }
    Type &Peek(){ //Получение значения вершины стека
        /*Type type;
        for(size_t i = 0; i < elements_.size(); ++i){
            if(elements_.at(i) == elements_.size() - 1){
                type = elements_.at(i);
            }
        }
        return type;*/
        //return elements_[static_cast<int>(elements_.size()) - 1];
        return elements_.back();
    }
    void Print() const{ // вывод в консоль
        PrintRange(elements_.begin(), elements_.end());
    }
    uint64_t Size() const{ //Размер стека — Size
        //return static_cast<uint64_t>(elements_.size());
        return elements_.size();
    }
    bool IsEmpty() const{ //Проверка на пустоту
        return elements_.empty();
    }
    const Type &Front() const{
        return elements_.front();
    }
    Type &Front(){
        return elements_.front();
    }
    ~Stack(){};
private:
    vector<Type> elements_;
};

template <typename Type>
class StackMin{
public:
    void Push(const Type &element){
        if(!minimum_.IsEmpty()){
            if(element > minimum_.Front().second){
                minimum_.Push({element, minimum_.Front().second});
            }
        } else{
            minimum_.Push({element,element});
        }
    }
    void Pop(){
        if(minimum_.Size() != 0 && minimum_.Front().second >= minimum_.Front().first){
            minimum_.Pop();
        }
    }
    const Type &Peek() const{
        return minimum_.Peek();
    }
    Type &Peek(){
        return minimum_.Peek();
    }
    void Print() const{
        minimum_.Print();
    }
    uint64_t Size() const{
        return minimum_.Size();
    }
    bool IsEmpty() const{
        return minimum_.IsEmpty();
    }
    const Type PeekMin() const{
        return minimum_.Front().second;
    }
    Type PeekMin(){
        return minimum_.Front().second;
    }
    ~StackMin(){};
private:
    Stack<pair<Type, Type>> minimum_;
};

int main(){
    setlocale(LC_ALL, "");
    StackMin<int> stack;
    //Stack<int> stack2;
    vector<int> values(5);
    iota(values.begin(), values.end(), 1);
    std::random_shuffle(values.begin(), values.end());
    //sort(values.begin(), values.end()/*,
    //    [](const int &i, const int &j){
    //        return (i > j);
    //    }*/
    //);
    //reverse(values.begin(), values.end());
    for(int i = 0; i < 5; ++i){
        stack.Push(values[i]);
    }

    while(!stack.IsEmpty()){
        stack.Print();
        cout << "Минимум = "s << stack.PeekMin() << endl;
        stack.Pop();
    }
}