理论上内存会到 100MB。

请使用 C++17 递交。

常数可能会大一点，因为处理了一些特殊情况（防止不负责任的出题老师）。

#define _CRT_SECURE_NO_WARNINGS
#include <cctype>
#include <cstdio>

#include <iostream>
#include <string>
#include <string_view>
#include <type_traits>
// 万能头就行了
using namespace std;

namespace fastIO
{
    // 开了 1e8 应该够
    char buffer[100'000'000];
    char *now = buffer, *end = buffer;

    inline void read_all()
    {
        end = buffer + fread(buffer, 1U, sizeof(buffer), stdin);
        if (!feof(stdin)) {
            abort();  // 一次读不完就 RE
        }
    }

    // 跳过空白
    inline bool skip_space() noexcept
    {
        while (now != end && isspace(*now)) {
            ++now;
        }

        return now != end;
    }

    // 整数输入，返回 true 代表可以继续输入，返回 false 代表已经读完了
    template <typename T, enable_if_t<is_integral_v<T>, int> = 0>
    inline bool read(T& value)
    {
        if (end == buffer) {
            read_all();
        }

        if (skip_space()) {
            int sign = 1;
            if (*now == '-') {
                sign = -1;
                value = 0;
            } else {
                value = *now - '0';
            }

            ++now;
            while (now != end && isdigit(*now)) {
                value = value * 10 + *(now++) - '0';
            }

            value *= sign;
            return true;
        } else {
            return false;
        }
    }

    // string 快读，返回值同上
    inline bool read(string& value)
    {
        if (skip_space()) {
            value.clear();
            char* old_now = now;
            while (now != end && !isspace(*now)) {
                ++now;
            }

            value.reserve(now - old_now);
            while (old_now != now) {
                value += *(old_now++);
            }
            return true;
        } else {
            return false;
        }
    }

    // 字符数组快读，返回值同上
    inline bool read(char* str)
    {
        if (skip_space()) {
            while (now != end && !isspace(*now)) {
                *(str++) = *(now++);
            }

            *str = '\0';
            return true;
        } else {
            return false;
        }
    }

    // 字符快读，返回值同上
    inline bool read(char& ch)
    {
        if (skip_space()) {
            ch = *(now++);
            return true;
        } else {
            return false;
        }
    }

    // 可以连着使用，例：read(a, b, c, d);
    // a, b, c, d 类型允许不同，返回值同上
    template <typename T, typename... Args>
    inline bool read(T& value, Args&... args)
    {
        return read(value) && read(args...);
    }

    // 数字快输
    template <typename T, enable_if_t<is_integral_v<T>, int> = 0>
    inline void write(T value)
    {
        if (value >= 0) {
            write<T>(value / 10);
            putchar(value % 10);  // 这边就不怎么优化了，也不会卡吧
        } else {
            putchar('-');
            write<T>(-value);
        }
    }

    // 包装的 scanf，语法一样，速度未经测试
    template <typename... Args>
    inline int fast_scanf(const char* format, Args... pointers)
    {
        if (end == buffer) {
            read_all();
        }

        int status = sscanf(now, format, pointers...);
        for (int i = 0; i < status; ++i) {
            ++now;
            while (!isspace(*now)) {
                ++now;
            }
        }

        return status;
    }

    // 字符输出 就简单包装了一下
    inline void write(char ch)
    {
        putchar(ch);
    }

    // 字符数组快输
    inline void write(const char* str, int len)
    {
        fwrite(str, 1U, len, stdout);
    }

    // string 快输
    inline void write(const string_view str)
    {
        write(str.data(), str.size());
    }

    // printf 直接调用就好了，没有什么好包装的
}  // namespace fastIO

int main()  // 例子
{
    using namespace fastIO;  // main 函数里加这一行
    int a;
    long long b;
    char c;
    // read(a, b, c);
    fast_scanf("%d", &a);
    read(b, c);
    int n = 0;
    int x;
    while (read(x)) {
        ++n;
    }

    cout << n << '\n' << a << ' ' << b << '\n' << c << '\n';
    return 0;
}

测试：

1 -1000000000000000 ? 3 4 5 7 3 7 4
^Z

7
1 -1000000000000000
?

P3583 记录

P3583 记录（优化）