如何控制较大整数相乘不会溢出

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef double db;

const int N = 1e5 + 50;
const int M = 1e5 + 50;
const int Mod = 1e9 + 7;

#define int long long

inline int read()
{
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9')
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
    {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    return x * f;
}

int n, m, q;

int a[N], b[N];

int w[N];

struct Segment
{
    int Max[N << 2], Min[N << 2];
    int ls(int p) { return p << 1; }
    int rs(int p) { return p << 1 | 1; }
    void push_up(int p)
    {
        Max[p] = max(Max[ls(p)], Max[rs(p)]);
        Min[p] = min(Min[ls(p)], Min[rs(p)]);
    }
    void build(int p, int l, int r, int k)
    {
        if (l == r)
        {
            if (k == 1)
            {
                Max[p] = w[l] >= 0 ? w[l] : -Mod;
                Min[p] = w[l] >= 0 ? w[l] : Mod;
            }
            else if (k == -1)
            {
                Max[p] = w[l] <= 0 ? w[l] : -Mod;
                Min[p] = w[l] <= 0 ? w[l] : Mod;
            }
            else
            {
                Max[p] = w[l];
                Min[p] = w[l];
            }
            return;
        }
        int mid = l + r >> 1;
        build(ls(p), l, mid, k);
        build(rs(p), mid + 1, r, k);
        push_up(p);
    }
    int query_max(int nx, int ny, int l, int r, int p)
    {
        int res = -Mod;
        if (nx <= l && r <= ny)
            return Max[p];
        int mid = l + r >> 1;
        if (nx <= mid)
            res = max(res, query_max(nx, ny, l, mid, ls(p)));
        if (ny > mid)
            res = max(res, query_max(nx, ny, mid + 1, r, rs(p)));
        return res;
    }
    int query_min(int nx, int ny, int l, int r, int p)
    {
        int res = Mod;
        if (nx <= l && r <= ny)
            return Min[p];
        int mid = l + r >> 1;
        if (nx <= mid)
            res = min(res, query_min(nx, ny, l, mid, ls(p)));
        if (ny > mid)
            res = min(res, query_min(nx, ny, mid + 1, r, rs(p)));
        return res;
    }
} Af, Az, B;

signed main()
{
    // freopen("a.in", "r", stdin);
    // freopen("a.out", "w", stdout);
    n = read(), m = read(), q = read();
    for (int i = 1; i <= n; ++i)
        a[i] = read();
    for (int i = 1; i <= m; ++i)
        b[i] = read();
    for (int i = 1; i <= n; ++i)
        w[i] = a[i];
    Az.build(1, 1, n, 1);
    for (int i = 1; i <= n; ++i)
        w[i] = a[i];
    Af.build(1, 1, n, -1);
    for (int i = 1; i <= m; ++i)
        w[i] = b[i];
    B.build(1, 1, m, 0);
    while (q--)
    {
        int l1 = read(), r1 = read(), l2 = read(), r2 = read();
        int s1 = Az.query_max(l1, r1, 1, n, 1) * B.query_min(l2, r2, 1, m, 1);
        int s2 = Az.query_min(l1, r1, 1, n, 1) * B.query_min(l2, r2, 1, m, 1);
        int s3 = Af.query_max(l1, r1, 1, n, 1) * B.query_max(l2, r2, 1, m, 1);
        int s4 = Af.query_min(l1, r1, 1, n, 1) * B.query_max(l2, r2, 1, m, 1);
        printf("%lld\n", max(max(s1, s2), max(s3, s4)));
    }
    return 0;
}