P5693 EI 的第六分块 Solution

Description

给定序列 $a=(a_1,a_2,\cdots ,a_n)$，有 $m$ 个操作分两种：

• $\mathrm{add}(l,r,v)$：对每个 $i\in [l,r]$ 执行 $a_i\leftarrow a_i+v$.
• $\mathrm{query}(l,r)$：求 $\max (0,\underset{[u,v]\in [l,r]}{\max }\sum _{i=u}^v{a}_i)$.

Limitations

$1\le n,m\le 4\times 10^5$
$1\le l\le r\le n$
$|a_i|\le 10^9$
$1\le v\le 10^6$
$1.8\text{s},256\text{MB}$

Solution

求最大子段和，显然要维护区间和 $\text{sum}$，最大前缀、后缀、子段和 $\text{lmax},\text{rmax},\text{tmax}$.
考虑区间加 $v$ 对这些值的影响：
如果选择的区间没有变，则答案要加上 $kv$，其中 $k$ 为该区间的长度.
考虑把上述四个值变成一次函数 $y=kx+b$，若选择区间不变则 $x$ 加上 $v$.
但选择的区间不是一成不变的，为了判断，我们需要维护阈值 $L$，表示若 $x\ge L$ 则四个值选择的区间至少会变一个.

pushup 时 $+$ 操作为一次函数相加，$\max$ 为函数在 $x=0$ 时的比较.
$L$ 取子节点的 $L$ 以及 $\text{lmax},\text{rmax}$ 两种方案，$\text{tmax}$ 三种方案的函数交点取最小（若小于 $0$ 或无交则变为 $\infty$）.

每次修改就把 $x$ 减去 $v$，若减后 $x<0$，则暴力遍历子树进行重构，若一棵子树的 $x\ge 0$ 就直接打标记而不进入.

上述即 KTT，时间复杂度约为 $O((n+m){\log }^{3}n)$，具体见 EI’s blog.
需要注意，上述方法建立在区间加正数这一基础上，否则反复重构会导致时间复杂度假掉.

Code

$5.67\text{KB},4.7\text{s},71.69\text{MB}\text{(in total, C++20 with O2)}$
只给一部分.

constexpr i64 inf = 4e18;

struct line {
    int k; i64 b;
    inline line() : line(0, 0) {}
    inline line(int _k, i64 _b): k(_k), b(_b) {}
    inline void add(i64 v) { b += k * v; }
};

inline line operator+(const line& lhs, const line& rhs) {
    return line(lhs.k + rhs.k, lhs.b + rhs.b);
}

inline pair<line, i64> _max(const line& a, const line& b) {
    if (a.k < b.k || (a.k == b.k && a.b < b.b)) return _max(b, a);
    if (a.b >= b.b) return make_pair(a, inf);
    return make_pair(b, (b.b - a.b) / (a.k - b.k));
}

struct info {
	line pre, suf, ans, sum;
	i64 x;
	inline info() {}
	inline info(line pre, line suf, line ans, line sum, i64 x)
	    : pre(pre), suf(suf), ans(ans), sum(sum), x(x) {}
};

inline info operator+(const info& a, const info& b) {
	i64 x0 = min(a.x, b.x);
	line sum = a.sum + b.sum;
	auto [pre, x1] = _max(a.pre, a.sum + b.pre);
	auto [suf, x2] = _max(b.suf, a.suf + b.sum);
	auto [tmp, x3] = _max(a.ans, b.ans);
	auto [ans, x4] = _max(tmp, a.suf + b.pre);
	return info(pre, suf, ans, sum, min({x0, x1, x2, x3, x4}));
}

inline void operator+=(info& a, i64 v) {
	a.x -= v;
    a.pre.add(v), a.suf.add(v);
    a.sum.add(v), a.ans.add(v);
}

struct node {
    int l, r;
    info dat;
    i64 tag;
};

inline int ls(int u) { return 2 * u + 1; }
inline int rs(int u) { return 2 * u + 2; }

struct ktt {
	vector<node> tr;
	inline ktt() {}
	inline ktt(const vector<i64>& a) {
		const int n = a.size();
		tr.resize(n << 1);
		build(0, 0, n - 1, a);
	}
	
	inline void pushup(int u, int mid) { tr[u].dat = tr[ls(mid)].dat + tr[rs(mid)].dat; }
	inline void apply(int u, i64 v) { tr[u].tag += v, tr[u].dat += v; }
	
	inline void pushdown(int u, int mid) {
	    if (tr[u].tag) {
	        apply(ls(mid), tr[u].tag);
	        apply(rs(mid), tr[u].tag);
	        tr[u].tag = 0;
	    }
	}
	
	inline void build(int u, int l, int r, const vector<i64>& a) {
	    tr[u].l = l, tr[u].r = r;
	    if (l == r) {
	        line f(1, a[l]);
	        tr[u].dat = info(f, f, f, f, inf);
	        return;
	    }
	    
	    const int mid = (l + r) >> 1;
	    build(ls(mid), l, mid, a);
	    build(rs(mid), mid + 1, r, a);
	    pushup(u, mid);
	}
	
	inline void defeat(int u, i64 v) {
        const int mid = (tr[u].l + tr[u].r) >> 1;
	    if (v > tr[u].dat.x) {
	        defeat(ls(mid), tr[u].tag + v);
	        defeat(rs(mid), tr[u].tag + v);
	        tr[u].tag = 0;
	        pushup(u, mid);
	    }
	    else apply(u, v);
	}
	
	inline void update(int u, int l, int r, i64 v) {
	    if (l <= tr[u].l && tr[u].r <= r) return defeat(u, v);
	    const int mid = (tr[u].l + tr[u].r) >> 1;
	    pushdown(u, mid);
	    if (l <= mid) update(ls(mid), l, r, v);
	    if (r > mid) update(rs(mid), l, r, v);
	    pushup(u, mid);
	}
	
	inline info query(int u, int l, int r) {
	    if (l <= tr[u].l && tr[u].r <= r) return tr[u].dat;
	    const int mid = (tr[u].l + tr[u].r) >> 1;
	    pushdown(u, mid);
	    if (r <= mid) return query(ls(mid), l, r);
	    if (l > mid) return query(rs(mid), l, r);
	    return query(ls(mid), l, r) + query(rs(mid), l, r);
	}
	
	inline void range_add(int l, int r, i64 v) { update(0, l, r, v); }
	inline i64 range_gss(int l, int r) { return max(query(0, l, r).ans.b, 0LL); }
};