P6792 & LOJ 3325 [SNOI2020] 区间和 Solution

原创已于 2025-08-15 17:53:51 修改 · 804 阅读

18 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数据结构 #c++ #线段树 #洛谷 #libreoj

于 2025-02-15 19:53:34 首次发布

洛谷题解同时被 2 个专栏收录

87 篇文章

订阅专栏

Loj 题解

8 篇文章

订阅专栏

Description

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

$\operatorname{chmax}(l,r,v)$ ：对每个 $\in [l,r]$ 执行 $a_i \gets \max(a_i,v)$ .
$\operatorname{query}(l,r)$ ：求 $\max(0,\max\limits_{[u,v]\in [l,r]}\sum\limits_{i=u}^v a_i)$ .

Limitations

$\le n \le 10^5$
$\le m \le 2\times 10^5$
$\le l \le r \le n$
$|a_i|,|v| \le 10^9$
$3\text{s},512\text{MB}$

Solution

看到 $\operatorname{chmax}$ 先来一个吉司机.
然后下传标记相当于区间加上 $(v-\min)$ ，这样就把问题变成区间加正数.
然后可以上 KTT 维护，具体见 P5693（这里把 $k$ 视作最小值的出现次数），要注意 pushup 时将两者间较大值的 $k$ 清零.
两套势能系统互相独立，故时间复杂度为 $O((n+m)\log^3n)$ .

Code

只给一部分.
$4.92\text{KB},4.71\text{s},21.16\text{MB}\;\texttt{(in total, C++20 with O2)}$

constexpr i64 inf = 3e18;

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 void reset() { k = 0; }
};

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 reset() {
        info res = *this;
        res.pre.reset();
        res.suf.reset();
        res.ans.reset();
        res.sum.reset();
        return res;
    }
};

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, min, sec;
};

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) {
		if (tr[ls(mid)].min == tr[rs(mid)].min) {
		    tr[u].min = tr[ls(mid)].min;
		    tr[u].sec = min(tr[ls(mid)].sec, tr[rs(mid)].sec);
		    tr[u].dat = tr[ls(mid)].dat + tr[rs(mid)].dat;
		}
		else if (tr[ls(mid)].min < tr[rs(mid)].min) {
		    tr[u].min = tr[ls(mid)].min;
		    tr[u].sec = min(tr[ls(mid)].sec, tr[rs(mid)].min);
		    tr[u].dat = tr[ls(mid)].dat + tr[rs(mid)].dat.reset();
		}
		else {
		    tr[u].min = tr[rs(mid)].min;
		    tr[u].sec = min(tr[ls(mid)].min, tr[rs(mid)].sec);
		    tr[u].dat = tr[ls(mid)].dat.reset() + tr[rs(mid)].dat;
		}
	}
	
	inline void apply(int u, i64 w) {
	    if (w <= tr[u].min) return;
	    
	    i64 v = w - tr[u].min;
	    tr[u].min = w;
	    tr[u].tag = max(tr[u].tag, w);
	    tr[u].dat += v;
	}
	
	inline void pushdown(int u, int mid) {
	    if (tr[u].tag != -inf) {
	        apply(ls(mid), tr[u].tag);
	        apply(rs(mid), tr[u].tag);
	        tr[u].tag = -inf;
	    }
	}
	
	inline void build(int u, int l, int r, const vector<i64>& a) {
	    tr[u].l = l, tr[u].r = r, tr[u].tag = -inf;
	    if (l == r) {
	        line f(1, a[l]);
	        tr[u].dat = info(f, f, f, f, inf);
	        tr[u].min = a[l], tr[u].sec = 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) {
	    tr[u].tag = max(tr[u].tag, v);
	    if (v - tr[u].min > tr[u].dat.x) {
            const int mid = (tr[u].l + tr[u].r) >> 1;
	        defeat(ls(mid), v);
	        defeat(rs(mid), v);
	        pushup(u, mid);
	    }
	    else apply(u, v);
	}
	
	inline void update(int u, int l, int r, i64 v) {
	    if (tr[u].min >= v) return;
	    if (l <= tr[u].l && tr[u].r <= r && v < tr[u].sec) 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_chmax(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); }
};