P8818 策略游戏 Sol

有一个人先手，肯定要选择使得最坏情况最优的点。

考虑分讨区间内元素情况。

1. \(a\) 为自然数，\(b\) 为自然数。

先手选择 \(\max\)，后手选择 \(\min\)。

2. \(a\) 为自然数，\(b\) 为负数。

先手选择 \(\min\)，后手选择 \(\min\)。因为先手如选择 \(\max\)，则后手选 \(\min\) 会使答案更小。

3. \(a\) 为自然数，\(b\) 无特殊限制。

同 2 情况。

4. \(a\) 为负数，\(b\) 为自然数。

先手选择 \(\max\)，后手选择 \(\max\)。要使得负数 \(\times\) 正数最大，先手需要让负数绝对值更小，后手则贪心地选择让乘积更小，选择区间最大值。

5. \(a\) 为负数，\(b\) 为负数。

这时候负负得正，先手选择 \(\min\) 会让后手被迫选择 \(\max\)。原因显然。

6. \(a\) 为负数，\(b\) 无特殊限制。

显然后手要选自然数，那么先手选择 \(\max\)。

7. \(a\) 无特殊限制，\(b\) 为自然数。

先手显然选 \(\max\)，后手显然选 \(\min\)。

8. \(a\) 无特殊限制，\(b\) 为负数。

先手显然选 \(\min\)，后手选 \(\max\)，负负得正，乘积最小。

9. \(a\) 无特殊限制，\(b\) 无特殊限制。

考虑两种情况，若先手选最小的自然数，则后手会选最小的负数来回应。

若先手选最大的负数，则后手会选择最大的自然数来回应。

取 \(\max\) 即可。

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

const int N = 1e5 + 10, Log = 20, inf = 1e9;
int n, m, q, lg[N], bn[Log];
ll a[N], b[N], Min[3][Log][N], Max[3][Log][N];

inline ll queryMin(int typ, int l, int r) {
	int k = lg[r - l + 1];
	return min(Min[typ][k][l], Min[typ][k][r - bn[k] + 1]);
} inline ll queryMax(int typ, int l, int r) {
	int k = lg[r - l + 1];
	return max(Max[typ][k][l], Max[typ][k][r - bn[k] + 1]);
}

inline void solve() {
	int l1, r1, l2, r2; scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
	ll Min1 = queryMin(0, l1, r1), Max1 = queryMax(0, l1, r1);
	ll Min2 = queryMin(1, l2, r2), Max2 = queryMax(1, l2, r2);
	ll ans = 0;
	if (Min1 >= 0) {
		if (Min2 >= 0) ans = Max1 * Min2;
		else if (Max2 < 0) ans = Min1 * Min2;
		else ans = Min1 * Min2;
	} else if (Max1 < 0) {
		if (Min2 >= 0) ans = Max1 * Max2;
		else if (Max2 < 0) ans = Min1 * Max2;
		else ans = Max1 * Max2;
	} else {
		if (Min2 >= 0) ans = Max1 * Min2;
		else if (Max2 < 0) ans = Min1 * Max2;
		else {
			ll fi = queryMin(2, l1, r1), se = queryMax(2, l1, r1);
			ans = max(fi * Min2, se * Max2);
		}
	}
	printf("%lld\n", ans); return ;
}

int main() {
	scanf("%d%d%d", &n, &m, &q);
	for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
	for (int i = 1; i <= m; ++i) scanf("%lld", &b[i]);
	bn[0] = 1; for (int i = 1; i < Log; ++i) bn[i] = bn[i - 1] << 1;
	lg[0] = -1; for (int i = 1; i < N; ++i) lg[i] = lg[i >> 1] + 1;
	for (int i = 1; i <= n; ++i) Min[0][0][i] = Max[0][0][i] = a[i];
	for (int i = 1; i < Log; ++i)
	  for (int j = 1; j + bn[i] - 1 <= n; ++j) {
	  	Min[0][i][j] = min(Min[0][i - 1][j], Min[0][i - 1][j + bn[i - 1]]);
	  	Max[0][i][j] = max(Max[0][i - 1][j], Max[0][i - 1][j + bn[i - 1]]);
		}
	for (int i = 1; i <= m; ++i) Min[1][0][i] = Max[1][0][i] = b[i];
	for (int i = 1; i < Log; ++i)
	  for (int j = 1; j + bn[i] - 1 <= m; ++j) {
		  Min[1][i][j] = min(Min[1][i - 1][j], Min[1][i - 1][j + bn[i - 1]]);
		  Max[1][i][j] = max(Max[1][i - 1][j], Max[1][i - 1][j + bn[i - 1]]);
	  }
  for (int i = 1; i <= n; ++i) {
  	if (a[i] >= 0) Min[2][0][i] = a[i]; else Min[2][0][i] = inf;
  	if (a[i] < 0) Max[2][0][i] = a[i]; else Max[2][0][i] = -inf;
	}
	for (int i = 1; i < Log; ++i)
	  for (int j = 1; j + bn[i] - 1 <= n; ++j) {
	  	Min[2][i][j] = min(Min[2][i - 1][j], Min[2][i - 1][j + bn[i - 1]]);
	  	Max[2][i][j] = max(Max[2][i - 1][j], Max[2][i - 1][j + bn[i - 1]]);
		}
  while (q--) solve();
  return 0;
}