#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;

bool operator<(string left, string right) {
    return left.size() < right.size();
}

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& element = elements_.back();
        return element;
    }
    Type& Peek() {
        return elements_.back();
    }
    void Print() const {
        for (const auto element : elements_) {
            cout << element << " ";
        }
        cout << endl;
    }
    uint64_t Size() const {
        return elements_.size();
    }
    bool IsEmpty() const {
        return elements_.empty();
    }

private:
    vector<Type> elements_;
};

template <typename Type>
class StackMin {
public:
    void Push(const Type& element) {
        // напишите реализацию метода
        if (element < minimum_) minimum_ = element;
        elements_.Push(element);
        minimum_vector_.push_back(make_pair(element, minimum_));
    }
    void Pop() {
        // напишите реализацию метода
        elements_.Pop();
        minimum_vector_.pop_back();
    }
    const Type& Peek() const {
        return elements_.Peek();
    }
    Type& Peek() {
        return elements_.Peek();
    }
    void Print() const {
        elements_.Print();
    }
    uint64_t Size() const {
        return elements_.size();
    }
    bool IsEmpty() const {
        return elements_.IsEmpty();
    }
    const Type& PeekMin() const {
        //const auto result = (minimum_vector_.back()).get<1>(minimum_vector_);
        const Type& result = minimum_vector_.back().second;
        return result;
    }

    Type& PeekMin() {
        return minimum_vector_.back().second;
    }
private:
    Stack<Type>                     elements_;
    vector<pair<Type, Type>>        minimum_vector_; //element minimum
    Type minimum_;
};

int main() {
    StackMin<string> stack;
    vector<string> values(4);
    // заполняем вектор для тестирования нашего стека
    values.push_back("aaaa");
    values.push_back("bbb");
    values.push_back("ddddd");
        // перемешиваем значения
    random_shuffle(values.begin(), values.end());
    // заполняем стек
    for (int i = 0; i < 4; ++i) {
        stack.Push(values[i]);
    }
    // печатаем стек и его минимум, постепенно убирая из стека элементы
    while (!stack.IsEmpty()) {
        stack.Print();
        cout << "Min = "s << stack.PeekMin() << endl;
        stack.Pop();
    }
}