P9631 [ICPC 2020 Nanjing R] Just Another Game of Stones Solution

原创已于 2025-09-14 14:57:37 修改 · 850 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

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

于 2025-02-23 20:56:41 首次发布

洛谷题解专栏收录该内容

87 篇文章

订阅专栏

Description

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

$chmax⁡(l,r,k)\operatorname{chmax}(l,r,k)$ ：对每个 $\in [l,r]$ 执行 $ai←max⁡(ai,k)a_i\gets\max(a_i,k)$ .
$query⁡(l,r,k)\operatorname{query}(l,r,k)$ ：用石堆 $al⋯ra_{l\cdots r}$ 和一堆 $k$ 个石子玩 Nim，求先手第一次取完石子后，后手必败的操作方案数.

Limitations

$\le n,m \le 2\times 10^5$
$\le a_i,k < 2^{30}$
$\le l \le r \le n$
$3s,256MB3\text{s},256\text{MB}$

Solution

考虑 $query⁡\operatorname{query}$ ，显然要维护 $xor⁡\operatorname{xor}$ 和用来判断先手是否必胜.
考虑如何求方案数，将 $k$ 算入，设 $s$ 为这局游戏的 SG 值，若先手必胜则策略显然为 $ai←aixor⁡sa_i \gets a_i \operatorname{xor} s$ ，所以把问题转化成求 $∑[ai>(aixor⁡s)]\sum [a_i > (a_i \operatorname{xor} s)]$ .
异或本质是不进位加法，若 $highbit⁡(s)=highbit⁡(ai)\operatorname{highbit}(s)=\operatorname{highbit}(a_i)$ ，则 $ai>(aixor⁡s)a_i > (a_i \operatorname{xor} s)$ 必成立.

然后需要一个 ds，支持区间 $chmax⁡\operatorname{chmax}$ ，求区间 $xor⁡\operatorname{xor}$ 和，求区间内第 $k$ 位为 $1$ 的数个数，用吉司机线段树即可，注意 $∞\infty$ 要开够.
时间复杂度 $O(mlog⁡nlog⁡V)O(m\log n\log V)$ .

Code

$O2)4.64\text{KB},0.55\text{s},57.78\text{MB}\;\texttt{(maximum, C++ 20 with O2)}$

// Problem: P9631 [ICPC2020 Nanjing R] Just Another Game of Stones
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P9631
// Memory Limit: 256 MB
// Time Limit: 3000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

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

using i64 = long long;
using ui64 = unsigned long long;
using i128 = __int128;
using ui128 = unsigned __int128;
using f4 = float;
using f8 = double;
using f16 = long double;

template<class T>
bool chmax(T &a, const T &b){
	if(a < b){ a = b; return true; }
	return false;
}

template<class T>
bool chmin(T &a, const T &b){
	if(a > b){ a = b; return true; }
	return false;
}

constexpr int inf = 2147483647;

namespace seg_tree {
	struct Node {
	    int l, r;
	    int min, sec, cnt, tag, sum;
	    array<int, 30> bits;
	};
	
	inline int ls(int u) { return 2 * u + 1; }
	inline int rs(int u) { return 2 * u + 2; }
	
	struct SegTree {
		vector<Node> tr;
		inline SegTree() {}
		inline SegTree(const vector<int>& 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].sum = tr[ls(mid)].sum ^ tr[rs(mid)].sum;
		    if (tr[ls(mid)].min == tr[rs(mid)].min) {
		        tr[u].min = tr[ls(mid)].min;
		        tr[u].cnt = tr[ls(mid)].cnt + tr[rs(mid)].cnt;
		        tr[u].sec = min(tr[ls(mid)].sec, tr[rs(mid)].sec);
		    }
		    else if (tr[ls(mid)].min < tr[rs(mid)].min) {
		        tr[u].min = tr[ls(mid)].min;
		        tr[u].cnt = tr[ls(mid)].cnt;
		    	tr[u].sec = min(tr[ls(mid)].sec, tr[rs(mid)].min);
		    }
		    else {
		        tr[u].min = tr[rs(mid)].min;
		        tr[u].cnt = tr[rs(mid)].cnt;
		        tr[u].sec = min(tr[ls(mid)].min, tr[rs(mid)].sec);
		    }
		    for (int i = 0; i < 30; i++) {
		        tr[u].bits[i] = tr[ls(mid)].bits[i] + tr[rs(mid)].bits[i];
		    }
		}
		
		inline void build(int u, int l, int r, const vector<int>& a) {
		    tr[u].l = l;
		    tr[u].r = r;
		    tr[u].tag = -1;
		    if (l == r) {
		        tr[u].min = tr[u].sum = a[l];
		        tr[u].sec = inf;
		        tr[u].cnt = 1;
		        for (int i = 0; i < 30; i++) tr[u].bits[i] = (a[l] >> i & 1);
		        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 apply(int u, int v) {
		    if (tr[u].min >= v) return;
		    tr[u].sum ^= (tr[u].cnt & 1) * (tr[u].min ^ v);
		    for (int i = 0; i < 30; i++)
		        tr[u].bits[i] += ((v >> i & 1) - (tr[u].min >> i & 1)) * tr[u].cnt;
		    tr[u].min = tr[u].tag = 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 = -1;
		    }
		}
		
		inline void update(int u, int l, int r, int v) {
		    if (tr[u].min >= v) return;
		    if (l <= tr[u].l && tr[u].r <= r && tr[u].sec > v) return apply(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 int qsum(int u, int l, int r) {
		    if (l <= tr[u].l && tr[u].r <= r) return tr[u].sum;
		    const int mid = (tr[u].l + tr[u].r) >> 1;
		    pushdown(u, mid);
		    if (r <= mid) return qsum(ls(mid), l, r);
		    else if (l > mid) return qsum(rs(mid), l, r);
		    else return qsum(ls(mid), l, r) ^ qsum(rs(mid), l, r);
		}
		
		inline int qbit(int u, int l, int r, int k) {
		    if (l <= tr[u].l && tr[u].r <= r) return tr[u].bits[k];
		    const int mid = (tr[u].l + tr[u].r) >> 1;
		    pushdown(u, mid);
		    if (r <= mid) return qbit(ls(mid), l, r, k);
		    else if (l > mid) return qbit(rs(mid), l, r, k);
		    else return qbit(ls(mid), l, r, k) + qbit(rs(mid), l, r, k);
		}
		
		inline void range_chmax(int l, int r, int v) { update(0, l, r, v); }
		inline int range_xorsum(int l, int r) { return qsum(0, l, r); }
		inline int range_bitsum(int l, int r, int k) { return qbit(0, l, r, k); }
	};
}
using seg_tree::SegTree;

signed main() {
	ios::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	
	int n, m;
	scanf("%d %d", &n, &m);
	vector<int> a(n);
	for (int i = 0; i < n; i++) scanf("%d", &a[i]);
	
	SegTree sgt(a);
	auto range_nim = [&](int l, int r, int x) {
	    int sg = sgt.range_xorsum(l, r) ^ x, bit = -1;
	    for (int i = 0; i < 30; i++)
	        if (sg >> i & 1) bit = i;
	    if (bit == -1) return 0;
	    return sgt.range_bitsum(l, r, bit) + (x >> bit & 1);
	};
	
	for (int i = 0, op, l, r, v; i < m; i++) {
	    scanf("%d %d %d %d", &op, &l, &r, &v), l--, r--;
	    if (op == 1) sgt.range_chmax(l, r, v);
	    else printf("%d\n", range_nim(l, r, v));
	}
	
	return 0;
}