P8563 Magenta Potion

题意

给定序列，多次求区间最大子段积。

解法

考虑线段树。

每个区间维护前缀最大值和最小值，后缀最大值和最小值，pushup 时只有可能最大乘以最大或最小乘以最小（负数乘以负数）。

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

#define ll __int128

const int N = 2e5 + 5, INF = 2e9, MOD = 1e9 + 7;

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

inline void write(ll x)
{
	if (x < 0) putchar('-'), x = -x;
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}

int n, q;
ll a[N], nans = LLONG_MIN;
bool flag;

class SegmentTree
{
public:
	struct Node
	{
		int l, r;
		ll lmaxn, rmaxn, mul, res;
		ll lminn, rminn, totalres;
		bool is_bigger;
	}tr[N << 2];
	Node merge(Node x, Node y)
	{
		if (x.l == -1) return y;
		if (y.l == -1) return x;
		Node z;
		z.mul = x.mul * y.mul;
		z.l = x.l, z.r = y.r;
		z.lmaxn = max({x.lmaxn, x.mul * y.lmaxn, x.mul * y.lminn, (ll)1, z.mul});
		z.rmaxn = max({(ll)1, y.rmaxn, y.mul * x.rmaxn, y.mul * x.rminn, z.mul});
		z.res = max({ x.res, y.res, x.rmaxn * y.lmaxn, z.mul, (ll)1 });
		z.lminn = min({x.lminn, x.mul * y.lminn, z.mul, (ll)1, x.mul * y.lmaxn});
		z.rminn = min({y.rminn, y.mul * x.rminn, z.mul, (ll)1, y.mul * x.rmaxn});
		z.totalres = max({x.totalres, y.totalres, (ll)1, z.res, x.rminn * y.lminn});
		if (z.totalres > (__int128)1 << 30)
		{
			z.is_bigger = 1;
		}
		else z.is_bigger = 0;
		z.is_bigger |= (x.is_bigger | y.is_bigger);
		return z;
	}
	void pushup(int u)
	{
		tr[u] = merge(tr[u << 1], tr[u << 1 | 1]);
	}
	void build(int u, int l, int r)
	{
		tr[u] = { l, r, a[l], a[l], a[l], a[l], a[l], a[l], a[l], 0 };
		tr[u].lmaxn = tr[u].rmaxn = tr[u].res = max(tr[u].res, (ll)1);
		tr[u].lminn = tr[u].rminn = min(tr[u].lminn, (ll)1);
		tr[u].totalres = max(tr[u].totalres, (ll)1);
		if (l == r) return;
		int mid = l + r >> 1;
		build(u << 1, l, mid);
		build(u << 1 | 1, mid + 1, r);
		pushup(u);
	}
	void update(int u, int p, ll x)
	{
		if (tr[u].l == tr[u].r)
		{
			tr[u].lmaxn = tr[u].rmaxn = tr[u].res = max(x, (ll)1);
			tr[u].lminn = tr[u].rminn = min(x, (ll)1);
			tr[u].totalres = max(x, (ll)1);
			tr[u].mul = x;
			return;
		}
		int mid = tr[u].l + tr[u].r >> 1;
		if (p <= mid) update(u << 1, p, x);
		else update(u << 1 | 1, p, x);
		pushup(u);
	}
	Node query(int u, int l, int r)
	{
		if (tr[u].l >= l and tr[u].r <= r) 
		{
			return tr[u];
		}
		int mid = tr[u].l + tr[u].r >> 1;
		Node ret;
		ret.l = -1;
		if (l <= mid) ret = query(u << 1, l, r);
		if (r > mid) ret = merge(ret, query(u << 1 | 1, l, r));
		return ret;
	}
}t;

int main()
{
	//freopen("C:\\Users\\60215\\Downloads\\T1ex1.in", "r", stdin);
	//freopen("C:\\Users\\60215\\Downloads\\tt.out", "w", stdout);
	// freopen("*.out", "w", stdout);
	scanf("%d%d", &n, &q);
	for (int i = 1; i <= n; i++) a[i] = read();
	t.build(1, 1, n);
	while (q--)
	{
		int opt;
		scanf("%d", &opt);
		if (opt == 1)
		{
			int x;
			scanf("%d", &x);
			ll y = read();
			t.update(1, x, y);
		}
		else
		{
			int l, r;
			scanf("%d%d", &l, &r);
			SegmentTree::Node ans = t.query(1, l, r);
			if (ans.is_bigger) printf("Too large\n");
			else
			{
				ll res = max((ll)1, ans.totalres);
				write(res);
				printf("\n");
			}
		}
	}
	return 0;
}