40pts玄关求调

#include<bits/stdc++.h>
#define ls (u << 1)
#define rs ((u << 1) | 1)
#define ll long long
using namespace std;
int read(){
	int sign = 1, cnt = 0;
	char c = getchar();
	while(!isdigit(c)){
		if(c == '-')	sign = -1;
		c = getchar();
	}
	while(isdigit(c)){
		cnt = cnt * 10 + (c ^ 48);
		c = getchar();
	}
	return sign * cnt;
}
const int N = 1e5 + 10, inf = 1e9 + 10;
int n, m, T;
int a[N], b[N];
struct node{
	int maxpos, minpos, maxneg, minneg, maxn, minn;
};

namespace tree{
	struct edge{
		int l, r;
		int a_maxpos = -1, a_minpos = inf, a_maxneg = -inf, a_minneg = 1, a_max = -inf, a_min = inf; 
		int b_maxpos = -1, b_minpos = inf, b_maxneg = -inf, b_minneg = 1, b_max = -inf, b_min = inf; 
	}tr[N << 2];
	
	void pushup(int u){
		tr[u].a_maxpos = max(tr[ls].a_maxpos, tr[rs].a_maxpos);
		tr[u].a_maxneg = max(tr[ls].a_maxneg, tr[rs].a_maxneg);
		tr[u].a_minpos = min(tr[ls].a_minpos, tr[rs].a_minpos);
		tr[u].a_minneg = min(tr[ls].a_minneg, tr[rs].a_minneg);
		tr[u].b_maxpos = max(tr[ls].b_maxpos, tr[rs].b_maxpos);
		tr[u].b_maxneg = max(tr[ls].b_maxneg, tr[rs].b_maxneg);
		tr[u].b_minpos = min(tr[ls].b_minpos, tr[rs].b_minpos);
		tr[u].b_minneg = min(tr[ls].b_minneg, tr[rs].b_minneg);
		tr[u].a_min = min(tr[ls].a_min, tr[rs].a_min);
		tr[u].a_max = max(tr[ls].a_max, tr[rs].a_max);
		tr[u].b_min = min(tr[ls].b_min, tr[rs].b_min);
		tr[u].b_max = max(tr[ls].b_max, tr[rs].b_max);
        // printf(">>%d\n", tr[u].b_minpos);
	}
	
	void build(int l, int r, int u){
		tr[u].l = l, tr[u].r = r;
		if(l == r){
			if(a[l] >= 0){
				tr[u].a_maxpos = tr[u].a_minpos = a[l];				
				// printf(">>>>%d\n", tr[u].b_minpos);
			}else{
				tr[u].a_maxneg = tr[u].a_minneg = a[l];
			}
            if(b[l] >= 0){
                tr[u].b_maxpos = tr[u].b_minpos = b[l];
            }else{
                tr[u].b_maxneg = tr[u].b_minneg = b[l];
            }
			tr[u].a_max = tr[u].a_min = a[l];
			tr[u].b_max = tr[u].b_min = b[l];
			// printf(">>>%d\n", tr[u].b_minpos);
			return;
		}
		int mid = (l + r) >> 1;
		build(l, mid, ls);
		build(mid + 1, r, rs);
		pushup(u);
	}
	
	node querya(int ql, int qr, int u){
		if(tr[u].l >= ql && tr[u].r <= qr)
			return {tr[u].a_maxpos, tr[u].a_minpos, tr[u].a_maxneg, tr[u].a_minneg, tr[u].a_max, tr[u].a_min};
		int mid = (tr[u].l + tr[u].r) >> 1;
		node ans = {-1, inf, -inf, 1, -inf, inf};
		if(mid >= ql){
			node qa = querya(ql, qr, ls);
			ans.maxpos = max(ans.maxpos, qa.maxpos);
			ans.maxneg = max(ans.maxneg, qa.maxneg);
			ans.minpos = min(ans.minpos, qa.minpos);
//			printf(">>%d\n", ans.minpos);
			ans.minneg = min(ans.minneg, qa.minneg);
			ans.maxn = max(ans.maxn, qa.maxn);
			ans.minn = min(ans.minn, qa.minn);
		}
		if(mid < qr){
			node qa = querya(ql, qr, rs);
			ans.maxpos = max(ans.maxpos, qa.maxpos);
			ans.maxneg = max(ans.maxneg, qa.maxneg);
			ans.minpos = min(ans.minpos, qa.minpos);
//			printf(">>%d\n", ans.minpos);
			ans.minneg = min(ans.minneg, qa.minneg);
			ans.maxn = max(ans.maxn, qa.maxn);
			ans.minn = min(ans.minn, qa.minn);
		}	
		return ans;
	}
	
	node queryb(int ql, int qr, int u){
		if(tr[u].l >= ql && tr[u].r <= qr)
			return {tr[u].b_maxpos, tr[u].b_minpos, tr[u].b_maxneg, tr[u].b_minneg, tr[u].b_max, tr[u].b_min};
		int mid = (tr[u].l + tr[u].r) >> 1;
		node ans = {-1, inf, -inf, 1, -inf, inf};
		if(mid >= ql){
			node qb = queryb(ql, qr, ls);
			ans.maxpos = max(ans.maxpos, qb.maxpos);
			ans.maxneg = max(ans.maxneg, qb.maxneg);
			ans.minpos = min(ans.minpos, qb.minpos);
//			printf(">>%d\n", ans.minpos);
			ans.minneg = min(ans.minneg, qb.minneg);
			ans.maxn = max(ans.maxn, qb.maxn);
			ans.minn = min(ans.minn, qb.minn);
		}
		if(mid < qr){
			node qb = queryb(ql, qr, rs);
			ans.maxpos = max(ans.maxpos, qb.maxpos);
			ans.maxneg = max(ans.maxneg, qb.maxneg);
			ans.minpos = min(ans.minpos, qb.minpos);
//			printf(">>%d\n", ans.minpos);
			ans.minneg = min(ans.minneg, qb.minneg);
			ans.maxn = max(ans.maxn, qb.maxn);
			ans.minn = min(ans.minn, qb.minn);
		}	
		return ans;
	}
}

int main(){
	n = read(), m = read(), T = read();
	for(int i = 1; i <= n; i++)	a[i] = read();
	for(int i = 1; i <= m; i++)	b[i] = read();
	tree::build(1, n, 1);
	while(T--){
		int l1 = read(), r1 = read(), l2 = read(), r2 = read();
		ll ans;
		node qa = tree::querya(l1, r1, 1), qb = tree::queryb(l2, r2, 1);
		bool fa[2] = {qa.minn >= 0, qa.maxn >= 0}, fb[2] = {qb.minn >= 0, qb.maxn >= 0};
		if(fb[0]){
			if(!fa[1])	ans = qa.maxneg *1ll * qb.maxpos;
			else ans = qa.maxn * 1ll * qb.minn;
		}else if(!fb[1]){
			if(!fa[0])	ans = qa.minneg * 1ll * qb.maxn;
			else	ans = qa.minpos *1ll * qb.minn;
		}else if(fb[1] && !fb[0]){
			if(fa[0])
				ans = qa.maxn * 1ll * qb.maxn;
			else if(!fa[1])
				ans = qa.minn * 1ll * qb.minn;
			else if(fa[1] && !fa[0])
				ans = max(qa.minpos * 1ll * qb.minneg, qa.maxneg * 1ll * qb.maxpos);
		}
		ll ans3 = (qa.minpos == 0 ? 0 : -inf);
		printf("%lld\n", max(ans, ans3));
	}
	return 0;
}