上个代码

这道题我没有压位的高精度都能在几十ms内ak，看来高精度的题的确效率要求是比较宽松的。

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

void trunc_zero(vector<int> &num) {
    while (num.empty() == false && num.back() == 0)
        num.pop_back();
}

struct Person {
    int lh;
    int rh;
    int mul;
} people[10002];

enum class Order { Equal, Less, Greater };

class Big_unsigned {
    friend ostream &operator<<(ostream &os, Big_unsigned const &a);
    vector<int> digits;

  public:
    Big_unsigned(string const &str) {
        digits.resize(str.size());
        auto i = digits.begin();
        auto j = str.rbegin();
        auto ed = digits.end();
        while (i != ed) {
            *i++ = *j++ - '0';
        }
    }

    Big_unsigned(vector<int> &&num) : digits(num) {}

    Big_unsigned operator*(int const a) const {
        vector<int> num(digits.size() + 10, 0);
        size_t i = 0;
        for (; i < digits.size(); ++i) {
            num[i] += digits[i] * a;
            if (num[i] >= 10) {
                num[i + 1] += num[i] / 10;
                num[i] %= 10;
            }
        }
        while (num[i] >= 10) {
            num[i + 1] += num[i] / 10;
            num[i] %= 10;
            ++i;
        }
        trunc_zero(num);
        return {move(num)};
    }

    Big_unsigned operator*(Big_unsigned const &a) const {
        vector<int> num(digits.size() + a.digits.size(), 0);
        size_t k;
        for (size_t i = 0; i < digits.size(); ++i) {
            for (size_t j = 0; j < a.digits.size(); ++j) {
                k = i + j;
                num[k] += digits[i] + a.digits[j];
                if (num[k] >= 10) {
                    num[k + 1] += num[k] / 10;
                    num[k] %= 10;
                }
            }
        }
        trunc_zero(num);
        return {std::move(num)};
    }

    Big_unsigned operator/(int const a) const {
        vector<int> num(digits.size());
        int accum = 0;
        for (int i = digits.size() - 1; i >= 0; --i) {
            accum = accum * 10 + digits[i];
            num[i] = accum / a;
            accum %= a;
        }
        trunc_zero(num);
        return {std::move(num)};
    }

    Order cmp(Big_unsigned const &a) const {
        if (digits.size() < a.digits.size()) {
            return Order::Less;
        } else if (digits.size() > a.digits.size()) {
            return Order::Greater;
        } else {
            auto i = digits.rbegin();
            auto j = a.digits.rbegin();
            auto ed = digits.rend();
            while (i != ed) {
                if (*i < *j) {
                    return Order::Less;
                } else if (*i > *j) {
                    return Order::Greater;
                } else {
                    ++i, ++j;
                }
            }
            return Order::Equal;
        }
    }
};

ostream &operator<<(ostream &os, Big_unsigned const &a) {
    if (a.digits.size() == 0) {
        os << '0';
    } else {
        auto i = a.digits.rbegin();
        auto ed = a.digits.rend();
        while (i != ed) {
            os << *i;
            ++i;
        }
    }
    return os;
}

int main() {
    int n;
    cin >> n;
    cin >> people[0].lh >> people[0].rh;
    people[0].mul = people[0].lh * people[0].rh;
    for (int i = 1; i <= n; ++i) {
        cin >> people[i].lh >> people[i].rh;
        people[i].mul = people[i].lh * people[i].rh;
    }
    sort(people + 1, people + 1 + n, [](Person a, Person b) { return a.mul < b.mul; });
    Big_unsigned accum(to_string(people[0].lh));
    Big_unsigned max_num(to_string(people[0].lh / people[1].rh));
    for (int i = 2; i <= n; ++i) {
        accum = accum * people[i - 1].lh;
        Big_unsigned temp = accum / people[i].rh;
        if (temp.cmp(max_num) == Order::Greater)
            max_num = std::move(temp);
    }
    cout << max_num << '\n';
}