7
push -2
push 0
push -3
getMin
pop
top
getMin

-3
0
-2

class Solution:
    class MinStack:
        def __init__(self):
            """ 初始化栈和辅助栈 """
            self.data_stack = []  # 数据栈
            self.min_stack = []   # 维护最小值的辅助栈

        def push(self, val: int):
            """ 将元素压入栈 """
            self.data_stack.append(val)
            # 只有当最小栈为空或新元素不大于最小栈的栈顶时，才推入最小栈
            if not self.min_stack or val <= self.min_stack[-1]:
                self.min_stack.append(val)

        def pop(self):
            """ 弹出栈顶元素 """
            if self.data_stack:
                top_element = self.data_stack.pop()
                if top_element == self.min_stack[-1]:  # 同步弹出最小栈的栈顶
                    self.min_stack.pop()

        def top(self) -> int:
            """ 返回栈顶元素 """
            return self.data_stack[-1] if self.data_stack else None

        def getMin(self) -> int:
            """ 返回栈中最小元素 """
            return self.min_stack[-1] if self.min_stack else None


if __name__ == "__main__":
    import sys
    input = sys.stdin.read
    data = input().split("\n")
    
    n = int(data[0])
    stack = Solution.MinStack()
    
    results = []
    for i in range(1, n + 1):
        command = data[i].split()
        if command[0] == "push":
            stack.push(int(command[1]))
        elif command[0] == "pop":
            stack.pop()
        elif command[0] == "top":
            results.append(str(stack.top()))
        elif command[0] == "getMin":
            results.append(str(stack.getMin()))
    
    print("\n".join(results))

import java.util.Scanner;
import java.util.Stack;

public class Main {
    public class Solution {
        class MinStack {
            private Stack<Integer> dataStack;
            private Stack<Integer> minStack;

            /** 初始化栈 */
            public MinStack() {
                dataStack = new Stack<>();
                minStack = new Stack<>();
            }

            /** 压入元素 */
            public void push(int val) {
                dataStack.push(val);
                if (minStack.isEmpty() || val <= minStack.peek()) {
                    minStack.push(val);
                }
            }

            /** 弹出栈顶元素 */
            public void pop() {
                if (!dataStack.isEmpty()) {
                    int topElement = dataStack.pop();
                    if (topElement == minStack.peek()) {
                        minStack.pop();
                    }
                }
            }

            /** 获取栈顶元素 */
            public int top() {
                return dataStack.peek();
            }

            /** 获取最小元素 */
            public int getMin() {
                return minStack.peek();
            }
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = Integer.parseInt(scanner.nextLine());
        Main main = new Main();
        Solution solution = main.new Solution();
        Solution.MinStack stack = solution.new MinStack();
        
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            String[] command = scanner.nextLine().split(" ");
            if (command[0].equals("push")) {
                stack.push(Integer.parseInt(command[1]));
            } else if (command[0].equals("pop")) {
                stack.pop();
            } else if (command[0].equals("top")) {
                sb.append(stack.top()).append("\n");
            } else if (command[0].equals("getMin")) {
                sb.append(stack.getMin()).append("\n");
            }
        }
        System.out.print(sb.toString());
    }
}

#include <iostream>
#include <stack>
#include <string>

using namespace std;

class Solution {
public:
    class MinStack {
    private:
        stack<int> dataStack;
        stack<int> minStack;
    public:
        /** 初始化栈 */
        MinStack() {}

        /** 压入元素 */
        void push(int val) {
            dataStack.push(val);
            if (minStack.empty() || val <= minStack.top()) {
                minStack.push(val);
            }
        }

        /** 弹出栈顶元素 */
        void pop() {
            if (!dataStack.empty()) {
                if (dataStack.top() == minStack.top()) {
                    minStack.pop();
                }
                dataStack.pop();
            }
        }

        /** 获取栈顶元素 */
        int top() {
            return dataStack.top();
        }

        /** 获取最小元素 */
        int getMin() {
            return minStack.top();
        }
    };
};

int main() {
    int n;
    cin >> n;
    cin.ignore(); 

    Solution::MinStack stack;
    string command;
    while (n--) {
        getline(cin, command);
        if (command.substr(0, 4) == "push") {
            int val = stoi(command.substr(5));
            stack.push(val);
        } else if (command == "pop") {
            stack.pop();
        } else if (command == "top") {
            cout << stack.top() << endl;
        } else if (command == "getMin") {
            cout << stack.getMin() << endl;
        }
    }
    return 0;
}