【洛谷】P1165 日志分析 题解

日志分析

题目链接

日志分析

题目描述

M 海运公司最近要对旗下仓库的货物进出情况进行统计。目前他们所拥有的唯一记录就是一个记录集装箱进出情况的日志。该日志记录了两类操作：第一类操作为集装箱入库操作，以及该次入库的集装箱重量；第二类操作为集装箱的出库操作。这些记录都严格按时间顺序排列。集装箱入库和出库的规则为先进后出，即每次出库操作出库的集装箱为当前在仓库里所有集装箱中最晚入库的集装箱。

出于分析目的，分析人员在日志中随机插入了若干第三类操作――查询操作。分析日志时，每遇到一次查询操作，都要报告出当前仓库中最大集装箱的重量。

输入格式

包含 $N+1$ 行：

第一行为一个正整数 $N$，对应于日志内所含操作的总数。

接下来的 $N$ 行，分别属于以下三种格式之一：

• 格式 1：0 X，表示一次集装箱入库操作，正整数 $X$ 表示该次入库的集装箱的重量。
• 格式 2：1，表示一次集装箱出库操作，（就当时而言）最后入库的集装箱出库。
• 格式 3：2，表示一次查询操作，要求分析程序输出当前仓库内最大集装箱的重量。

当仓库为空时你应该忽略出库操作，当仓库为空查询时你应该输出 $0$。

输出格式

输出行数等于日志中查询操作的次数。每行为一个整数，表示查询结果。

样例 #1

样例输入 #1

13
0 1
0 2
2
0 4
0 2
2
1
2
1
1
2
1
2

样例输出 #1

2
4
4
1
0

提示

数据范围及约定

• 对于 $20\%$ 的数据，有 $N\le 10$；
• 对于 $40\%$ 的数据，有 $N\le 1000$；
• 对于 $100\%$ 的数据，有 $1\le N\le 200000$，$1\le X\le 10^8$。

题解思路

题目中提到了两个重要的操作，出库和入库。而出库，选择的是出掉最后入库的集装箱，这不由得让人想起一个典型的数据结构——栈。
不过题目中还提到了一个查询当前仓库中最重的集装箱，这就不是一个简单的栈了。如果当前栈为空或者当前入栈的数大于栈顶，那么正常入栈。反之，栈中元素应该增加，但是不应该放当前数，而是存入当前栈中最大数，即栈顶元素，维持栈内非单调递增。在这种情况下，我们可以随时得到栈内最大元素值，而不用去从前面寻找最大值。

如果你没有学过栈，也完全可以根据题目意思和题解想法，使用数组写一个栈——参考第三段代码。

题解代码

C++版

#include <bits/stdc++.h>
using namespace std;

class MyStack
{
private:
    stack<int> st;

public:
    void push(int weight)
    {
        if (st.empty() || weight > st.top())
        {
            st.push(weight);
        }
        else
        {
            st.push(st.top());
        }
    }

    void pop()
    {
        if (!st.empty())
        {
            st.pop();
        }
    }

    int query()
    {
        if (!st.empty())
        {
            return st.top();
        }
        return 0;
    }
};

int main()
{
    MyStack stack;
    int t;
    cin >> t;
    while (t-- > 0)
    {
        int ac;
        cin >> ac;
        if (ac == 0)
        {
            int num;
            cin >> num;
            stack.push(num);
        }
        if (ac == 1)
        {
            stack.pop();
        }
        if (ac == 2)
        {
            cout << stack.query() << endl;
        }
    }
    return 0;
}

Java版

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

public class Main {

    static class MyStack {
        private Stack<Integer> stack;

        public MyStack() {
            stack = new Stack<>();
        }

        public void push(int weight) {
            if (stack.isEmpty() || weight > stack.peek()) {
                stack.push(weight);
            } else {
                stack.push(stack.peek());
            }
        }

        public void pop() {
            if (!stack.isEmpty()) {
                stack.pop();
            }
        }

        public int query() {
            if (!stack.isEmpty()) {
                return stack.peek();
            }
            return 0;
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        MyStack stack = new MyStack();
        int t = sc.nextInt();
        while (t-- > 0) {
            int ac = sc.nextInt();
            if (ac == 0) {
                int num = sc.nextInt();
                stack.push(num);
            }
            if (ac == 1) stack.pop();
            if (ac == 2) System.out.println(stack.query());
        }
        sc.close();
    }
}

不使用自带栈的C++代码

#include <bits/stdc++.h>
using namespace std;
#define N 200001

class MyStack
{
private:
    int nums[N];
    int len = 0;

public:
    void push(int weight)
    {
        if (len == 0 || weight > nums[len - 1])
        {
            nums[len] = weight;
        }
        else
        {
            nums[len] = nums[len - 1];
        }
        ++len;
    }

    void pop()
    {
        if (len >= 0)
        {
            --len;
        }
    }

    int query()
    {
        if (len == 0)
            return 0;
        return nums[len - 1];
    }
};

int main()
{
    MyStack stack;
    int t;
    cin >> t;
    while (t-- > 0)
    {
        int ac;
        cin >> ac;
        if (ac == 0)
        {
            int num;
            cin >> num;
            stack.push(num);
        }
        if (ac == 1)
        {
            stack.pop();
        }
        if (ac == 2)
        {
            cout << stack.query() << endl;
        }
    }
    return 0;
}