玄铭的博客

你好，我是玄铭

Tue, 12 May 2026 00:00:00 +0000

你好，欢迎来到我的博客。

我是玄铭，一名网络安全方向的博士生。

这个博客用来记录我在学习、研究和生活中的一些思考与积累，内容可能涵盖算法竞赛、网络安全技术、日常随笔等方向。

如果你也对这些话题感兴趣，欢迎一起交流。

四边形不等式优化DP小结

Thu, 01 Oct 2020 00:00:00 +0000

定义

四边形不等式用于优化形如以下类型dp：

$$ f(i) = \min_{1 \leq j \leq i} w(j,i) \qquad \left(1 \leq i \leq n\right) \tag{1} $$

其中$w(j,i)$满足：

$$ 若a\le b\le c\le d\\ 有w(a,c)+w(b,d)\le w(a,d)+w(b,c) $$

若满足以上条件，约定$opt(i)$表示对于$i$来说最优决策点$j$的位置，则有：

$$ i_1\le i_2 \Rightarrow opt(i_1)\le opt(i_2) $$

以上性质称为决策单调性。

两种基本方法

分治法

要求解所有状态，只需要求解所有最优决策点。为了对所有 $1 \leq i \leq n$ 求解 $\mathop{\mathrm{opt}}(i)$，首先计算 $\mathop{\mathrm{opt}}(n/2)$，而后分别计算 $1 \leq i < n/2$ 和 $n/2 < i \leq n$ 上的 $\mathop{\mathrm{opt}}(i)$，注意此时已知前半段的 $\mathop{\mathrm{opt}}(i)$ 必然位于 $1$ 和 $\mathop{\mathrm{opt}}(n/2)$ 之间（含端点），而后半段的 $\mathop{\mathrm{opt}}(i)$ 必然位于 $\mathop{\mathrm{opt}}(n/2)$ 和 $\mathop{\mathrm{opt}}(n)$ 之间（含端点）。对于两个子区间，也类似处理，直至计算出每个问题的最优决策。在分治的过程中记录搜索的上下边界，就可以保证算法复杂度控制在 $O(n\log n)$。递归树层数为 $O(\log n)$，而每层中，单个决策点至多计算两次，所以总的计算次数是 $O(n\log n)$。

int w(int j, int i);
void DP(int l, int r, int k_l, int k_r) {
 int mid = (l + r) / 2, k = k_l;
 // 求状态f[mid]的最优决策点
 for (int j = k_l; j <= min(k_r, mid - 1); ++j)
 if (w(j, mid) < w(k, mid)) k = j;
 f[mid] = w(k, mid);
 // 根据决策单调性得出左右两部分的决策区间，递归处理
 if (l < mid) DP(l, mid - 1, k_l, k);
 if (r > mid) DP(mid + 1, r, k, k_r);
}

二分队列

注意到对于每个决策点 $j$，能使其成为最小最优决策点的问题 $i$ 必然构成一个区间。可以通过单调队列记录到目前为止每个决策点可以解决的问题的区间，这样，问题的最优解自然可以通过队列中记录的决策点计算得到。算法大致如下。

int val(int j, int i);
int lt[N], rt[N], f[N];
deque<int> dq;
// 初始化队列
dq.emplace_back(1);
lt[1] = 1;
rt[n] = n;
// 顺次考虑所有问题和决策
for (int j = 1; j <= n; ++j) {
 // 出队
 while (!dq.empty() && rt[dq.front()] < j) {
 dq.pop_front();
 }
 // 计算
 f[j] = val(dq.front(), j);
 // 入队
 while (!dq.empty() && val(j, lt[dq.back()]) < val(dq.back(), lt[dq.back()])) {
 dq.pop_back();
 }
 if (dq.empty()) {
 dq.emplace_back(j);
 lt[j] = j + 1;
 rt[j] = n;
 } else if (val(j, rt[dq.back()]) < val(dq.back(), rt[dq.back()])) {
 if (rt[dq.back()] < n) {
 dq.emplace_back(j);
 lt[j] = rt[dq.back()] + 1;
 rt[j] = n;
 }
 } else {
 int ll = lt[dq.back()];
 int rr = rt[dq.back()];
 int i;
 // 二分
 while (ll <= rr) {
 int mm = (ll + rr) / 2;
 if (val(j, mm) < val(dq.back(), mm)) {
 i = mm;
 rr = mm - 1;
 } else {
 ll = mm + 1;
 }
 }
 rt[dq.back()] = i - 1;
 dq.emplace_back(j);
 lt[j] = i;
 rt[j] = n;
 }
}

掌握这一算法，需要理解如下要点：

队列需要记录到目前为止每个可行的决策点 $j$ 和能够解决的问题区间左右端点 $l_j$ 和 $r_j$ 构成的 三元组。对于给定区间 $[l_j,r_j]$ 内的问题，$j$ 应该是到目前为止考虑过的决策点中最小最优的（以下简称最优决策）。每时每刻，队列中存储的决策未必是连续的，但是尚未解决的问题应该是队列中存储的问题区间的不交并。
初始化：将首个决策放于队列中，并记录它对于所有问题都是最优的。
类似于单调队列，每次考虑下一个决策 $j$ 的时候，都需要进行出队和入队操作。
出队：当所有决策 $j \leq i$ 都考虑结束后，问题 $i$ 的解就是队列中首个满足 $l_j \leq i \leq r_j$ 的决策点 $j$。此时可以弹出所有满足 $r_j < i$ 的队首。由于决策单调性，弹出的决策也不会是后续问题的最优决策。
入队：要对决策 $j$ 进行入队时，首先比较它和队尾的决策 $j'$。
- 如果对于问题 $l_{j'}$，将入队的决策 $j$ 比已有的决策 $j'$ 更优，即 $w(j,l_{j'}) < w(j',l_{j'})$ 时，则弹出队尾的决策 $j'$。此操作持续到队尾的决策 $j'$ 比起 $j$ 对于问题 $l_{j'}$ 更优时为止。
- 如果队列已空，入队 $(j,j+1,n)$，即认为决策 $j$ 是尚未解决的所有问题的最优解。
- 如果队尾决策 $j'$ 对于问题 $r_{j'}$ 同样优于将入队的决策 $j$，那么当 $r_{j'} < n$ 时，入队 $(j,r_{j'}+1,n)$，表示 $j$ 是对于问题 $[r_{j'}+1,n]$ 的最优解，否则，不需要入队 $j$，因为它并不比已有的决策更优。
- 最后的情形是，队尾决策 $j'$ 比起要入队的决策 $j$ 对于问题 $l_{j'}$ 更优，而对于问题 $r_{j'}$ 更劣，那么，需要通过二分找到最小的 $i\in[l_{j'},r_{j'}]$ 使得 $w(j,i) < w(j',i)$，将队尾的区间右端点修改为 $i-1$，并入队 $(j,i,n)$。

两种基本问题

区间分拆问题

考虑将某个区间拆分成若干个子区间的问题。形式化地说，将给定区间 $[1,n]$ 拆分成 $[a_1,b_1],\cdots,[a_k,b_k]$，其中，$b_1=1$，$a_k=n$，以及 $b_{i}+1=a_{i+1}$ 对任意 $i < k$ 都成立。对于给定拆分，成本为 $\sum_{i=1}^kw(a_i,b_i)$。问题要求最小化这一成本。可以列出如下的 1D1D 状态转移方程。

$$ f(i) = \min_{1\leq j\leq i} f(j-1)+w(j,i) \qquad (1\leq i\leq n) $$

这里，$f(0)=0$。注意到，只要 $w(j,i)$ 满足四边形不等式，$f(j-1)+w(j,i)$ 必然满足四边形不等式，因为第一项并不包括 $j$ 和 $i$ 的交叉项，在混合差分时会消去。但是由于成本函数依赖于前面的子问题，这一转移只能够顺序计算，所以通常只适合应用二分队列算法。算法复杂度为 $O(n\log n)$。

上述问题可以加强为限制区间个数的情形，即问题指定将区间拆分成 $m$ 个子区间。此时需要将拆分后的区间个数作为转移状态的一维。相应地，有 2D1D 状态转移方程如下。

$$ f(k,i) = \min_{1\leq j\leq i} f(k-1,j-1)+w(j,i) \qquad (1\leq k\leq m,\ 1\leq i\leq n) \tag{2} $$

有以下引理：

若 $w$ 满足四边形不等式，则 $\mathop{\mathrm{opt}}(k-1,i) \leq \mathop{\mathrm{opt}}(k,i) \leq \mathop{\mathrm{opt}}(k,i+1)$。

利用这一结果，我们可以限制决策 $j$ 的搜索范围。算法实现时，对 $k$ 正向遍历，对 $i$ 逆向遍历，在之前已确定的上下界范围内暴力搜索 $j$ 就可以保证 $O(n(n+m))$ 的算法复杂度。

另有wqs二分可以优化到$O(n\log n\log C)$。

区间合并问题

另一类可以通过四边形不等式优化的动态规划问题是区间合并问题，即要将 $n$ 个长度为一的区间 $[i,i]$ 两两合并起来，直到得到区间 $[1,n]$。每次合并 $[j,k]$ 和 $[k+1,i]$ 时都需要支付成本 $w(j,i)$。问题要求找到成本最低的合并方式。对于此类问题，有如下 2D1D 状态转移方程。

$$ f(j,i) = \min_{j \leq k < i} f(j,k) + f(k+1,i) + w(j,i) \qquad (1\le j< i\le n) \tag{3} $$

这里给定任意初始成本 $f(i,i)=w(i,i)$。

可以证明$f(j,i)$满足四边形不等式，且有以下定理：

$$ \mathop{\mathrm{opt}}(j,i-1) \leq \mathop{\mathrm{opt}}(j,i) \leq \mathop{\mathrm{opt}}(j+1,i). \qquad (j + 1 < i) $$

利用这一结论，同样可以限制决策点 $k$ 的搜索范围。在这里，正序遍历区间长度 $i-j+1$，再遍历具有同样长度的所有区间 $[j,i]$，暴力搜索 $\mathop{\mathrm{opt}}(j,i-1)$ 和 $\mathop{\mathrm{opt}}(j+1,i)$ 之间的所有 $k$ 求得最优解 $f(j,i)$ 并记录最小最优决策 $\mathop{\mathrm{opt}}(j,i)$。总的算法复杂度为 $O(n^2)$ 。

参考资料

OI-Wiki 四边形不等式优化

2257推导

Wed, 01 Jan 2020 00:00:00 +0000

$$ \sum_{x=1}^n\sum_{m=1}^n [gcd(x,y)=1] \\ = \sum_{x=1}^n\sum_{m=1}^n\sum_{d\mid gcd(x,y)} \mu(d) \\ = \sum_{x=1}^n\sum_{m=1}^n\sum_{d\mid x,d\mid y} \mu(d) \\ \text{此时x,y便独立开来，调换求和顺序} \\=\sum_{d=1}^{min(n,m)} \mu(d) \lfloor\frac{n}{d}\rfloor\lfloor\frac{m}{d}\rfloor $$

对于本题的问题，有

$$ \sum_{p\in P}\sum_{x=1}^n\sum_{y=1}^m[gcd(x,y)=p] \\ =\sum_{p\in P}\sum_{x=1}^{\lfloor\frac{n}{p}\rfloor}\sum_{y=1}^{\lfloor\frac{m}{p}\rfloor}[gcd(x,y)=1] \\ =\sum_{p\in P}\sum_{x=1}^{\lfloor\frac{n}{p}\rfloor}\sum_{y=1}^{\lfloor\frac{m}{p}\rfloor}\sum_{d\mid x,d\mid y}\mu(d) \\=\sum_{p\in P} \sum_{d=1}^{\lfloor \frac{min(n,m)}{p} \rfloor}\mu(d) \lfloor\frac{n}{pd}\rfloor\lfloor\frac{m}{pd}\rfloor \\\text{令t=pd} \\=\sum_{t=1}{min(n,m)} \lfloor\frac{n}{t}\rfloor\lfloor\frac{m}{t}\rfloor\sum_{p\in P,p\mid t}\mu(\frac{t}{p}) \\令f(n)=[n\in P],且 \\g(n)=\sum_{p\in P,p\mid n}\mu(\frac{n}{p}) \\则g=f*u $$

2303推导

Wed, 01 Jan 2020 00:00:00 +0000

$$ \sum_{i=1}^n gcd(i,n)=\sum_{d\mid n} \sum_{i=1}^n [gcd(i,n)=d] \ =\sum_{d\mid n} \sum_{i=1}^{\lfloor \frac{n}{d} \rfloor} [gcd(i,n)=1] =\sum_{d\mid n} \varphi(\frac{n}{d})

CF1200D题解

Wed, 01 Jan 2020 00:00:00 +0000

突然发现自己的做法很清奇，于是就来写一篇题解了。

~~觉得自己还是可以，居然没用二维的东西维护答案~~

题意是在一个黑白矩阵上选一个小矩形染色为白，让全白的行列最多。

Part.1

考虑一种最暴力的做法，我们枚举小矩阵的左上角，暴力染色后统计行列的数量。

这个算法的时间复杂度为$O((n-k)^2*k)$，可以通过$n,k<=400$或$n,k$值接近的点。

但这个算法在$k=\frac{n}{2}$时复杂度会被卡成$O(n^3)$。~~但如果出题人数据水可能可以比正解跑的快~~

Part.2

先来考虑一列的答案。

如果这一列全是白色，无论在哪里时它都有贡献，先预处理出来。

考虑我们在每次枚举到$i,j$，往$i,j+1$继续枚举时，我们只用转移一列，如图。

此时只有两边的答案更新了，我们只需要考虑如何更新这两列的答案即可。

考虑对每一列做一个前缀和统计黑点的个数，每次从答案中减去左边那列的贡献，加上右边的贡献就可以了（贡献就是如果这段的黑点个数等于这列的黑点个数，答案就加一）。

Part.3

我们再来考虑如何统计一行的贡献。

如果这一行全是白色，同理的，先预处理出来。

同样的，我们在从$i$往$i+1$枚举时，也只用更新一行的答案。

考虑如何统计一行的贡献，先只看一行，我们枚举到$i$时包含了$[i,i+k-1]$这个区间。

我们考虑只有这个区间包含了所有黑点时才对答案有贡献，所以我们只用记录下最左边的黑点与最右边的黑点。

如图，只有在包含了整个区间时才有贡献，如果它的区间大小没有整个区间大，那这行就永远没有贡献。

所以拓展到$k$行，我们只需要计算枚举到$i$时每行的一个区间时对答案是否有贡献即可。

但这里是不是要用到数据结构呢，实际上不用，我们这里的问题比这个要弱的多。

显然$[i,i+k-1]$这个区间它只有它的左端点决定，我们可以只统计这个区间的左端点在哪个区间合法。

设左黑点的位置是$L$，右黑点的位置是$R$，那么整个区间能被全覆盖的充要条件是$R-k+1\leq i\leq L$，那么我们只需要对$[R-k+1,L]$区间打标记即可。

这里这个步骤的的实现不需要用任何数据结构，考虑我们只用枚举的每一行进行一次这样的操作，需要$n-k$次，但是我们的查询操作需要每个位置进行一次，即$(n-k)^2$次。所以我们可以直接用一个数组暴力打标记，这样是$O(n)$的，查询查一个点，是$O(1)$的，可以通过。

总时间复杂度除开读入外是$O((n-k)\times n)$的，可以通过。

$Code$

#include <cstdio>
#include <iostream>
using namespace std;
const int maxn=2005;

char s[maxn][maxn];
int sum[maxn][maxn];
int vis[maxn],n,k;
int L[maxn],R[maxn],hans,lans,ans,llans;

inline int max(const int &x,const int &y)
{
 return x>y?x:y;
}

int main()
{
 scanf("%d%d",&n,&k);
 for(int i=1;i<=n;++i)
 scanf("%s",s[i]+1);
 for(int i=1;i<=n;++i)
 for(int j=1;j<=n;++j)
 if(s[i][j]=='B') {L[i]=j;break;}
 for(int i=1;i<=n;++i)
 for(int j=n;j>0;--j)
 if(s[i][j]=='B') {R[i]=j;break;}
 for(int j=1;j<=n;++j)
 {
 for(int i=1;i<=n;++i)
 {
 sum[i][j]=sum[i-1][j];
 if(s[i][j]=='B') sum[i][j]++;
 }
 if(sum[n][j]==0) llans++;
 }
 for(int i=1;i<=n;++i)
 if(L[i]==0&&R[i]==0) hans++;
 for(int i=1;i<=k;++i)
 {
 if(R[i]-L[i]+1>k) continue;
 for(int j=max(1,R[i]-k+1);j<=L[i];++j)
 ++vis[j];
 }
 for(int i=1;i<=n-k+1;++i)
 {
 if(i!=1)
 {
 for(int j=max(1,R[i-1]-k+1);j<=L[i-1];++j) 
 --vis[j];
 for(int j=max(1,R[i+k-1]-k+1);j<=L[i+k-1];++j) 
 ++vis[j];
 }
 lans=llans;
 for(int j=1;j<=k;++j)
 if(sum[n][j]&&sum[i+k-1][j]-sum[i-1][j]==sum[n][j]) lans++;
 ans=max(ans,lans+vis[1]);
 for(int j=2;j<=n-k+1;++j)
 {
 if(sum[n][j-1]&&sum[i+k-1][j-1]-sum[i-1][j-1]==sum[n][j-1]) lans--;
 if(sum[n][j+k-1]&&sum[i+k-1][j+k-1]-sum[i-1][j+k-1]==sum[n][j+k-1]) lans++;
 ans=max(ans,lans+vis[j]);
 }
 }
 printf("%d\n",ans+hans);
 return 0;
}

码字不容易，求过$QwQ$。

~~另外图是不是有点丑~~

CF1427A翻译

Wed, 01 Jan 2020 00:00:00 +0000

给你一个序列$a$，要求你把它重排成一个新序列$b$，使$b$的所有前缀和均不为$0$。

如果存在$b$，输出YES以及你构造的$b$，否则输出NO。

CF1427B翻译

Wed, 01 Jan 2020 00:00:00 +0000

你喜欢下国际象棋。

现在你下了n局象棋，如果你赢了，并且上一局也赢了，则可以得到两分，如果上一局输了则得到一分，否则不得分。

现在你可以开挂将k局输了的棋改为赢了，你要使自己的得分最大，输出最大得分。

输入的字符串W代表胜利，L代表失败。

CF1427C翻译

Wed, 01 Jan 2020 00:00:00 +0000

你是一个狗仔。

城市是一个$r\times r$的平面，你在第0秒时在$(1,1)$，每一秒可以向上下左右移动一格，城市里会有一些名人出现，第$i$个名人会在第$t_i$秒出现在$(x_i,y_i)$，如果你在那一秒恰好在那里，就可以给他照一张照片，询问你最多可以给几个名人照相。

读入第一行包含两个数$n,r$。

接下来每行三个数$t_i,x_i,y_i$，保证$t_i$递增。

CF1446C翻译

Wed, 01 Jan 2020 00:00:00 +0000

给定你一个序列$a$，对于每个$i$，它会向序列中的满足$a_i\oplus a_j$（$\oplus$代表异或）最小的$j$连双向边，并且如果$j$也向$i$连了边，只算一条边。现在要让你删去序列中的一些数，使得最后形成的图是一颗树，输出最少需要删除几个数。

Translated by 试试事实上吗.

CF1447B

Wed, 01 Jan 2020 00:00:00 +0000

题意很清晰，首先关注翻转的性质，有一个结论：

实际上每次可以翻转任意两个数。

为什么呢？考虑比如我们要翻转$(x_1,y_1),(x_2,y_2)(x_1\le x_2,y_1\le y_2)$，我们可以一路翻转$(x_1,y_1),(x_1,y_1+1)$，再翻转$(x_1,y_1+1),(x_1,y_1+2)$，一直到$(x_1,y_2-1),(x_1,y_2)$。同理我们可以一路翻转到$(x_2,y_2)$，可以发现，除了两个端点$(x_1,y_1),(x_2,y_2)$，一路上所有的点都被翻转了两次翻回来了，所以就实现了翻转任意两个数。

接下来就很简单了。首先如果负数是偶数个，那么可以直接翻转，否则必然要剩下一个，我们就选取矩形中绝对值最小的数作为剩下的负数就可以了。

代码：

#include <cstdio>
#include <iostream>
using namespace std;
const int maxn=105;

int n,m;

int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		int cnt=0,ans=0,mi=101;
		scanf("%d%d",&n,&m);
		for(int i=1,x;i<=n;++i)
			for(int j=1;j<=m;++j)
			{
				scanf("%d",&x);
				if(x<0) x=-x,++cnt;
				mi=min(mi,x);ans+=x;
			}
		if(cnt&1) printf("%d\n",ans-mi*2);
		else printf("%d\n",ans);
	}
	return 0;
}

CSP2020游记

Wed, 01 Jan 2020 00:00:00 +0000

2020.10.11 初赛

早上起来头晕的要死，突然想到今天是初赛，感觉整个人都要裂开了。。。

然而还是只有强迫自己调整状态，终于还是调整过来了。

到了发现考场竟然是在小学一年级的教室里，真的无语了。。

这桌子还没有我的大腿高，~~难道CCF缺钱已经到了这种地步了？~~

今年的卷子感觉难度还是跟昨年差不多，只不过坑点有点多。

1）一看$2^{10}$不就是最大的，下一个。

2）~~只要不是用脚选，应该都不会选错~~

3）$2048 \times 1024\times (32/8)\times 24\times 8\times 60/2^{30}\approx 90$。

4）前几年的原题，但是换成了栈底，~~真tm坑~~。

5）一看$A,B,C$等价直接选$D$走人。

6）背包是$dp$

7）又是一个原题。

8）好像还是原题。设左边有$x$个点，右边有$y$个点，$x+y=24$，求$(x\times y)_{max}$，直接均值不等式，下一个。

9）常识，~~没有人错吧~~

10）$CRT$，但没必要，直接枚举$x\times 7+4$，再看一下另外两个合不合法就可以了。

11）等差数列，$f(x)=5\times x\times (x-1)$，算一算就可以了。

12）转就可以了。

13）先选一个，有$16$种，剩下的另一个还有$9$个格子可以放，然后每对答案算了两遍除以2就可以了。

14）常识。

15）常识，而且又是原题。

16 - 20

实际上d[i]+d[j]-(d[i]&d[j])就是d[i]|d[j]，然后就没有了。

21 - 25

只递归一边的快排，$T(n)=T(\frac n 2)+n=O(n)$，然后没什么好说的。

26 - 30

好像是个双向$bfs$，复杂度不会算（听说是$O(n\times n!)$），反正不太会。

31 - 35

就是个裸贪心，没什么好说的。

36 - 40

猜的答案，不过挺好猜的。（不过$v$初值好像是$0$）

考到一半的时候，外面竟然在放崩坏世界的歌姬，~~真tm离谱，这比赛的管理就这么差吗~~，不过歌好评。

2020.11.7 CSP-S

T1

出题人你****，1582年后全过，1582年前爆炸珂海星，考试时想到了有1月0日，但是我判了1582年后，没有判1582年前，在洛谷炸成10分。

T2

十年竞赛一场空，开了$\text{unsigned long long }$也见祖宗。

考场上20分钟秒$A$，但被卡了$\text{1ull<<64}$，也没啥说的。

T3

还好，由于sbT1耽误了太多的时间，所以打了个暴力，话说牛客的数据这个sb乱搞可以拿80分。

T4

考场上想出了一个可以过80分的做法，但是大样例有几个答案始终大1，有点崩，但还好有25分。

估分$\text{100+100+30+20=250}$。

洛谷得分$\text{10+90+30+25=155}$。

牛客得分$\text{20+90+80+35=215}$。

~~这次出T1T2的人肯定心里黑暗，故意报复社会~~

$update$ T4暴力改出来了，在你谷有80分，一共只改了不到十个字符，我****

$update$ 感谢T1出题人数据放一条生路，实际得分：$\text{50+95+70+20=235}$

luoguP3850题解

Wed, 01 Jan 2020 00:00:00 +0000

~~题外话：这个题不是裸题吗~~

~~看好题解比较少我就进来了~~

$FHQ\_treap$维护区间

能维护区间的平衡树比较少，本蒟蒻只会$splay$与$fhq$

~~我也只会这两种平衡树~~

平衡树维护区间与一般的平衡树的定义有点不同，一棵维护区间的平衡树满足：

它的任意一个节点任何一个左儿子的下标比它小，右儿子比它大。

节点维护size，在split时按size分。

#include <cstdio>
#include <iostream>
#include <string>
#include <algorithm>
#include <ctime>
using namespace std;
const int maxn=1e5+205;

struct FHQ_Node
{
	int ch[2],siz,rnd;
	string val;
}tr[maxn];
int utot;

inline int newnode(string val) {tr[++utot].rnd=rand();tr[utot].siz=1;tr[utot].val=val;return utot;}

inline void update(int u) {tr[u].siz=tr[tr[u].ch[0]].siz+tr[tr[u].ch[1]].siz+1;}

inline void split(int u,int siz,int &x,int &y)
{
	if(!u) return void(x=y=0);
	if(tr[tr[u].ch[0]].siz>=siz) y=u,split(tr[u].ch[0],siz,x,tr[u].ch[0]);//左儿子的size+1表示它在区间中的排名
	else x=u,split(tr[u].ch[1],siz-tr[tr[u].ch[0]].siz-1,tr[u].ch[1],y);
	update(u);
}

inline int merge(int x,int y)
{
	if(!x||!y) return x|y;
	if(tr[x].rnd<tr[y].rnd)
	{
		tr[x].ch[1]=merge(tr[x].ch[1],y);update(x);return x;
	}
	else
	{
		tr[y].ch[0]=merge(x,tr[y].ch[0]);update(y);return y;
	}
}

int main()
{
	ios::sync_with_stdio(false);
	srand(time(0));
	int n,rt=0,r1=0,r2=0,x,m,q;
	string s;
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>s;
		rt=merge(rt,newnode(s));
	}
	cin>>m;
	while(m--)
	{
		cin>>s>>x;
		split(rt,x,rt,r1);
		rt=merge(rt,merge(newnode(s),r1));
	}
	cin>>q;
	while(q--)
	{
		cin>>x;
		split(rt,x+1,rt,r1);
		split(rt,x,rt,r2);
		cout<<tr[r2].val<<endl;
		rt=merge(rt,merge(r2,r1));
	}
	return 0;
}

另外，听说$splay$在维护区间的时候比$fhq$要快~~但主要是因为$fhq$好打~~

luogu题解 CF767C 【Garland】

Wed, 01 Jan 2020 00:00:00 +0000

Part.1

一开始完全没有思路,想了一下，如果是分成两棵树，那就好做多了，首先想到的是统计一下以当前节点为根的子树的权值和，如果和为$sum\times\frac{1}{2}$，那么我们就找到了一个解。考虑我们也类似地记录一个$siz$表示以当前节点为根的子树的权值和，只要为$sum\times\frac{1}{3}$，它就可能是解的一个。

Part.2

我们在一遍$dfs$后可以找出可能很多是$sum\times\frac{1}{3}$的解，那么我们应该怎么选择呢？很容易想到，我们应该找到$LCA$不同的两个点，我们就找到了一组解。

Part.3

上述解法实际上是存在问题的（~~想一想，为什么~~）

我们考虑类似下面的一棵树：

很显然这棵树上子树权值和为$sum\times\frac{1}{3}$只有三号节点，但我们能不能把他分成三棵树呢？很显然是可以的（每个节点都分成一棵树），我们的解法应进一步考虑。考虑二号节点，它的权值和是$sum\times\frac{2}{3}$，那我们怎么处理呢？难道要把所有的$sum\times\frac{1}{3}$与$sum\times\frac{2}{3}$算出来，然后再一一匹配吗？

我们考虑另一种解法。$dfs$的特点是要在处理完儿子后才会处理当前节点，考虑儿子中有一个$sum\times\frac{1}{3}$，如果我们吧儿子的$sum\times\frac{1}{3}$变成$0$，那么它自身也变成了$sum\times\frac{1}{3}$，我们此时只用一个数组统计为$sum\times\frac{1}{3}$的节点就ok了，那么如果有两个儿子都是$sum\times\frac{1}{3}$呢？我们一定会先处理儿子，那么儿子都被统计了，自然就找到答案了。

我们只用输出找到的前两个答案即可。（这两个答案一定是我们上述提到的两种关系）

最后奉上高清无码的代码：

#include <cstdio>
#include <iostream>
using namespace std;
const int maxn=1e6+5;

struct edge
{
 int v,nxt;
}e[maxn<<1];
int head[maxn],kt;
int t[maxn],rt,n;
int ans[10],tot;
int sum;
template<typename T>
inline void read(T &x)
{
 char c;int f=1;
 while(!isdigit(c=getchar())) (c=='-')&&(f=-1);
 x=c^48;
 while(isdigit(c=getchar())) x=(x<<1)+(x<<3)+(c^48);
 x*=f;
}

inline void add(int u,int v) {e[++kt]=(edge){v,head[u]};head[u]=kt;}

void dfs(int u,int f)
{
 for(int i=head[u];i;i=e[i].nxt)
 if(e[i].v!=f)
 {
 dfs(e[i].v,u);
 t[u]+=t[e[i].v]; 
 }
 if(t[u]==sum/3)
 ans[++tot]=u,t[u]=0;
}

int main()
{
 int x;
 read(n);
 for(int i=1;i<=n;i++)
 {
 read(x);read(t[i]);
 sum+=t[i];
 if(x) add(x,i),add(i,x);
 else rt=i;
 }
 if(sum%3)
 {
 puts("-1");
 return 0;
 }
 dfs(rt,0);
 if(tot<=2) puts("-1");
 else printf("%d %d\n",ans[1],ans[2]);
 return 0;
}

第七届Code+程序设计全国挑战赛 normal T1 最小路径串

Wed, 01 Jan 2020 00:00:00 +0000

题目描述

n 个点 m 条边的无向图中，所有点用从 0 开始的 6 位数字串编号，即 000000、000001、000002、……直到 $n−1$ 对应的 6 位数字串。保证 $n≤1e6$，所以 6 位的编号不会溢出。

对于除了 000000 以外的每个点，你需要找到一条从 000000 出发且不经过重复点的路径，使得路径上所有点的数字串顺次连接形成的串的字典序最小。

比较两个不同的串的字典序的方法是：如果其中某个串是另一个的前缀，则较短的串字典序较小；否则，找出两个串从左往右扫描时遇到的首个不相等的位置，在这个位置上的数字较小的串字典序较小。

由于输出路径过于麻烦，你不需要完整地输出路径，只需要将路径上所有点的数字串视作一个整数，输出这个数对 998244353 取模的结果。

输入格式

从标准输入读入数据。

第一行输入两个整数 $n$ 和 $m$。

第二行输入一个长度为 $12m$ 的数字串，依次表示每条边。每条边用 12 个数字表示，其中前 6 个与后 6 个数字分别表示这条边所连接的两个点的编号。

注意，输入中可能会包含自环或重边。

输出格式

输出到标准输出。

输出 n−1 行，依次输出除了点 000000 本身以外，点 000000 到每个点的字典序最小的路径，视为整数后对 998244353 取模的结果。

如果点 000000 不可到达某个点，则在对应的行改为输出 -1。

样例1输入

5 5
000000000003000001000003000001000002000002000000000002000003

样例1输出

样例1解释

从 000000 到 000001 所求的路径对应的串为 000000000002000001。从 000000 到 000002 所求的路径对应的串为 000000000002。从 000000 到 000003 所求的路径对应的串为 000000000002000001000003，对 998244353 取模后为 517560944。从 000000 到 000004 不存在路径。

子任务

子任务1（11分） $1≤n≤1e6,m=0$。

子任务2（55分）

$1≤n≤10,0≤m≤20$。

子任务3（34分）

$1≤n≤1e6,0≤m≤1e6$。

刚开始拿到这道题的时候还有点晕，首先我们可以否定直接吧路径字符串存下来，我们可以把字符串转化成数来存储。但是我们就无法比较两条路径的字典序先后，但我们又可以发现，一条路径最优，当且仅当它的每一个路径上的数都是最小，但不一定是最短，则我们有以下dfs代码：

#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;
const int maxs=1e7+2e6+100,maxn=1e6+50;
typedef long long ll;
const ll mod=998244353;
vector<int> e[maxn];
int n,m;
char s[maxs];
ll ans[maxn];

inline bool cmp(const int &a,const int &b) {return a<b;}

void dfs(int u,ll dis)
{
 ans[u]=dis;
 int siz=e[u].size();
 for(int i=0;i<siz;i++)
 if(ans[e[u][i]]==-1) dfs(e[u][i],(dis*1000000+e[u][i])%mod);
}

int main()
{
 int u,v;
 scanf("%d%d%s",&n,&m,s);
 memset(ans,-1,sizeof(ans));
 for(int i=1;i<=m;i++)
 {
 u=v=0;
 for(int j=(i-1)*12;j<i*12-6;j++)
 u=(u<<1)+(u<<3)+(s[j]^48);
 for(int j=i*12-6;j<i*12;j++)
 v=(v<<1)+(v<<3)+(s[j]^48);
 if(u==v) continue;
 e[u].push_back(v);e[v].push_back(u);
 }
 for(int i=0;i<n;i++) sort(e[i].begin(),e[i].end(),cmp);
 dfs(0,0);
 for(int i=1;i<n;i++) printf("%lld\n",ans[i]);
 return 0;
}

题解 CF1427A 【Avoiding Zero】

Wed, 01 Jan 2020 00:00:00 +0000

这题巨降智。。

做法1：真按它说的随机打乱，1000次左右还没有解就认为无解。

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn=55;

int a[maxn],n;

bool check()
{
	int sum=0;
	for(int i=1;i<=n;++i)
	{
		sum+=a[i];
		if(sum==0) return 0;
	}
	puts("YES");
	for(int i=1;i<=n;++i)
		printf("%d ",a[i]);
	putchar('\n');
	return 1;
}

int main()
{
	int t,flag;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&n);flag=0;
		for(int i=1;i<=n;++i)
			scanf("%d",a+i);
		for(int i=1;i<=1000;++i)
		{
			random_shuffle(a+1,a+n+1);
			if(check()) {flag=1;break;}
		}
		if(!flag) puts("NO");
	}
	return 0;
}

不知道为啥没卡。。。

然而我们观察前缀和的性质，我们先求整个序列的和，如果大于0则说明正数多，就从大到小排一遍序，小于0则负数多，从小到大排序，这样可以保证每个前缀和均不为0。如果和为0则无解，直接输出NO。

然后就没有了。

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn=55;

int a[maxn],n,sum;

bool cmp(const int &x,const int &y)
{
 return x>y;
}

int main()
{
	int t,flag;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&n);flag=sum=0;
		for(int i=1;i<=n;++i)
			scanf("%d",a+i),sum+=a[i];
 if(sum==0) {puts("NO");continue;}
		if(sum>0) sort(a+1,a+n+1,cmp);
 else sort(a+1,a+n+1);
 puts("YES");
 for(int i=1;i<=n;++i)
 printf("%d ",a[i]);
 puts("");
	}
	return 0;
}

题解 CF380D 【Sereja and Cinema】

Wed, 01 Jan 2020 00:00:00 +0000

一道有趣的组合题。

我们先考虑什么样的入座方式是合法的。

结论：一个入座方式是合法的，当且仅当任意时刻已经入座的人都是一个连通块。

证明很显然，假设有两个连通块，那么它们最终会相遇，在相遇的地方，一定有不合法的一个位置。

然后我们就可以做了。

我们先考虑第一个人的位置，如果已经确定了，那么我们就找到她的位置，如果没有确定，我们就枚举起点。

先对已经确定顺序的人排序。

模拟连通块的扩展，我们考虑记录当前连通块的左端点为l，右端点为r。

我们考虑下一个已经确定的人的入座位置在pos，如果$l\le pos \le r$，那么就不合法，返回0。

否则如果$posr$同理，不再讨论）

假设上一个入座的与这个人之间有x个人要入座，如果$x

最后统计所有情况答案求和即可。

题解 CF510D 【Fox And Jumping】

Wed, 01 Jan 2020 00:00:00 +0000

由裴蜀定理知道，$ax+by=gcd(a,b)$，存在一组$x,y$使该式成立，显然当$gcd(a,b)=x$时，可以跳到$x$的倍数的位置，当$gcd(a,b)=x$时，可以跳到纸带上的任意一个位置。将该式推广到$n$个数显然也成立。抽象一下，我们假设现在已经可以走到$x$了，我们枚举下一个位置，实际上就像是在做最短路，我们可以直接跑一边最短路就可以了，我用了$\text{dijsktra}$，由于值域很大，用$\text{unordered_map}$代替$\text{dis}$和$\text{vis}$数组就可以了，目前是最优解。

#include <cstdio>
#include <iostream>
#include <unordered_map>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll,int> pii;
const int maxn=305;
const ll inf=1e18;

unordered_map<int,int> vis;
unordered_map<int,ll> dis;
priority_queue<pii,vector<pii>,greater<pii> > que;
int c[maxn],n,l[maxn];

inline int gcd(int x,int y)
{
	while((x%=y)&&(y%=x));
	return x|y;
}

int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;++i) scanf("%d",l+i);
	for(int i=1;i<=n;++i) scanf("%d",c+i);
	dis[0]=0;
	que.push(make_pair(0,0));
	while(!que.empty())
	{
		int u=que.top().second;que.pop();
		if(u==1) break;
		if(vis.find(u)!=vis.end()) continue;
		vis[u]=1;
		for(int i=1;i<=n;++i)
		{
			int v=gcd(u,l[i]);
			if(dis.find(v)==dis.end()) dis[v]=inf;
			if(dis[v]>dis[u]+c[i])
			{
				dis[v]=dis[u]+c[i];
				que.push(make_pair(dis[v],v));
			}
		}
	}
	if(dis.find(1)==dis.end()) puts("-1");
	else printf("%lld\n",dis[1]);
	return 0;
}

题解 CF842D 【Vitya and Strange Lesson】

Wed, 01 Jan 2020 00:00:00 +0000

感觉应该是个经典问题，亏我还不知道。

实际上就是询问你集合中的数都异或上某个数的的$\text{mex}$。

考虑常用的操作异或集合的手段，我的第一反应是线性基，然而线性基只能插入，不能修改，再者她也不能查询$\text{mex}$这么奇怪的东西。

先不考虑异或，显然$\text{mex}$是有可二分性的，我们需要一个数据结构支持查询小于某个数的数是否都出现过，然后我们就可以二分了，我的第一反应是值域线段树，显然是可以做的，直接在线段树上二分就可以了，具体来说走到线段树的某个节点时，看一下左儿子存在的数是不是等于左儿子对应的值域大小，即看一下左儿子是不是满的。然而，线段树也不能维护异或这么奇怪的东西。

实际上我们可以选取和线段树结构相同的另一个数据结构（或者说她们就是同一个东西），$\text{01trie}$。

我们也可以在$\text{01trie}$上二分查$\text{mex}$，并且走到$\text{trie}$上某个点时，如果异或的数这一位为1，意义就是交换$\text{trie}$的左右儿子，然后就可以用和线段树一样的方法做了。

有一个细节就是，在计算$\text{trie}$一个点的$\text{size}$时，注意一个数出现多次只计算一次。

其他具体实现可以看一下代码，还是比较易懂的。

#include <cstdio>
#include <iostream>
using namespace std;
const int maxn=3e5+5,Lim=18;

int tr[maxn*19][2],nowxor,cnt=1,siz[maxn*19],n,m;

template<typename T>
inline void read(T &x)
{
 char c;int f=1;
 while(!isdigit(c=getchar())) (c=='-')&&(f=-1);
 x=c^48;
 while(isdigit(c=getchar())) x=x*10+(c^48);
 x*=f;
}

void insert(int x,int u=1,int now=Lim)
{
 if(now==-1) return siz[u]=1,void();
 int s=x>>now&1;
 if(!tr[u][s]) tr[u][s]=++cnt;
 insert(x,tr[u][s],now-1);
 siz[u]=siz[tr[u][0]]+siz[tr[u][1]];
}

inline int query(int x=nowxor)
{
 int u=1,res=0;
 for(int i=Lim;i>=0;--i)
 {
 int s=x>>i&1;
 if(siz[tr[u][s]]==((1<<i))) u=tr[u][s^1],res|=(1<<i);
 else u=tr[u][s];
 if(!u) return res;
 }
 return res;
}

int main()
{
 int x;
 read(n);read(m);
 for(int i=1;i<=n;++i)
 read(x),insert(x);
 while(m--)
 {
 read(x);nowxor^=x;
 printf("%d\n",query());
 }
 return 0,QAQ;
}

题解 P3066 【[USACO12DEC]Running Away From the Barn G】

Wed, 01 Jan 2020 00:00:00 +0000

题意很清晰，我们可以用前缀和转化一下，设$u$到根的距离为$dis[u]$，则在$u$的子树中满足到$u$的距离不大于$t$的点$v$满足

$$ dis[v]-dis[u]\leq t $$

即

$$ dis[u]+t\geq dis[v] $$

我们先跑一边$dfs$，每个点的子树就对应一段区间，然后问题就转化成了：求一段区间内小于等于某个数的值有几个，裸的主席树。

然后上板子即可，但细节有点多。

$Code$

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn=2e5+5;

struct edge
{
 int v,nxt;
 ll w;
 edge(int v=0,ll w=0,int nxt=0) :v(v),w(w),nxt(nxt){}
}e[maxn<<1];
int lc[maxn<<5],rc[maxn<<5],sum[maxn<<5];
int rt[maxn],tot;
int head[maxn],kt,dfn[maxn],siz[maxn],n,cnt,m,id[maxn];
ll dis[maxn],b[maxn],t;

template<typename T>
inline void read(T &x)
{
 char c;int f=1;
 while(!isdigit(c=getchar())) (c=='-')&&(f=-1);
 x=c^48;
 while(isdigit(c=getchar())) x=x*10+(c^48);
 x*=f;
}

inline void add(int u,int v,ll w)
{
 e[++kt] = edge(v, w, head[u]);
 head[u] = kt;
}

void dfs(int u,int fa,ll ds)
{
 dis[u] = ds;siz[u] = 1;
 dfn[u] = ++cnt;id[cnt]=u;
 for (int i = head[u];i;i=e[i].nxt)
 if(e[i].v!=fa) {
 dfs(e[i].v, u, ds + e[i].w);
 siz[u] += siz[e[i].v];
 }
}

void build(int &u,int l,int r)
{
 u=++tot;
 if(l==r) return;
 int mid=(l+r)>>1;
 build(lc[u],l,mid);build(rc[u],mid+1,r);
}

void insert(int &u,int pre,int l,int r,int x)
{
 u=++tot;lc[u]=lc[pre];rc[u]=rc[pre];sum[u]=sum[pre]+1;
 if(l==r) return;
 int mid=(l+r)>>1;
 if(x<=mid) insert(lc[u],lc[pre],l,mid,x);
 else insert(rc[u],rc[pre],mid+1,r,x);
}

int query(int u,int v,int l,int r,int x,int y)
{
 if(r<x||l>y) return 0;
 if(x<=l&&r<=y) return sum[v]-sum[u];
 int mid=(l+r)>>1;
 return query(rc[u],rc[v],mid+1,r,x,y)+query(lc[u],lc[v],l,mid,x,y);
}

int main()
{
 int u;
 ll w;
 read(n);read(t);
 for (int i=2;i<=n;++i)
 {
 read(u);read(w);
 add(i,u,w);add(u,i,w);
 }
 dfs(1,0,0);
 for(int i=1;i<=n;++i) b[i]=dis[i];
 sort(b+1,b+n+1);b[n+1]=1e18;
 m=unique(b+1,b+n+2)-b-1;
 build(rt[0],1,m);
 for(int i=1;i<=n;++i)
 insert(rt[i],rt[i-1],1,m,lower_bound(b+1,b+m+1,dis[id[i]])-b);
 for(int i=1;i<=n;++i)
 {
 int x=lower_bound(b+1,b+m+1,dis[i])-b-1,y=lower_bound(b+1,b+m+1,dis[i]+t)-b-1;
 if(b[x+1]==dis[i]) ++x;if(b[y+1]==dis[i]+t) ++y;
 if(y==m-1) printf("%d\n",siz[i]); 
 else printf("%d\n",query(rt[dfn[i]-1],rt[dfn[i]+siz[i]-1],1,m,x,y));
 }
 return 0;
}

题解 P3765 【总统选举】

Wed, 01 Jan 2020 00:00:00 +0000

很有意思的一道题。

Part.1

一开始拿到这道题一看，题目要求的是区间众数的出现次数，这个显然没法做，据我所知只有静态分块或者回滚莫队可以做不带修版本的，但是他要我们求的比这个要弱许多，我们可以发现一个性质，显然如果一个数出现次数超过一半，我们让它与剩下的数两两抵消，剩下的数必然只有它自己。更进一步，如果区间中一旦有一个满足条件的数，我们任意选两个数抵消，剩下的必然是那个数。

我们用数据结构实现这个过程。

考虑一棵线段树，她维护区间中两两抵消还剩哪个数以及还剩多少。她的左右儿子信息合并时，我们看两个儿子剩下的数是否一样，如果一样就相加，如果不一样就取最大，然后互相抵消。

Part.2

然后，你以为做完了？

如果真做完了那么它最多是绿题。

我们刚才假设了区间绝对满足条件，那么如果区间不满足条件呢？~~暴力找~~

一个显然的做法是对每一个总统建一个$vector$，每次找出答案后再$vector$中二分询问区间的左右端点，然后看中间数的个数是否大于$len/2$就可以了。

然而题目中有修改。~~暴力修改~~

于是实际上，我们要支持一个数据结构，插入一个数，删除一个数，查询某个数的排名（相当与二分）

这是什么？平衡树板子。

然后，然后就真的完了。

总结一下，我们每次在线段树上找出一个数，然后再在平衡树上找出区间中该数的个数检查是否合法就可以了。

Part.3

安利一下$LeafyTree$，即$WBLT$，她的形态与线段树差不多，常数小跑的飞快，一般比$Splay$或$FHQTreap$快两到三倍。

最后一个细节，在找排名的时候，一路走到叶子后一定要看一下这个数是不是比叶子大，如果小要$return\;0$，因为这个数可能比平衡树中的所有数都小。

Code

struct Node
{
 int siz,val;
 Node *lc,*rc;
 Node(int siz,int val,Node *lc,Node *rc) : siz(siz),val(val),lc(lc),rc(rc) {}
 Node() {}
}*null,*stk[maxn*3],utk[maxn*3];
int utot,a[maxn],n;

struct Leafy_Tree
{
 Node *rt[maxn];
 #define newnode(a,b,c,d) (&(*stk[utot++]=Node(a,b,c,d)))
 #define merge(a,b) newnode(a->siz+b->siz,b->val,a,b)
 inline void init()
 {
 for(int i=1;i<=n;++i)
 rt[i]=newnode(1,0x3f3f3f3f,null,null);
 }
 inline void rotate(Node *u)
 {
 if(u->lc->siz > u->rc->siz*ratio)
 u->rc=merge(u->lc->rc,u->rc),stk[--utot]=u->lc,u->lc=u->lc->lc;
 else if(u->rc->siz > u->lc->siz*ratio)
 u->lc=merge(u->lc,u->rc->lc),stk[--utot]=u->rc,u->rc=u->rc->rc;
 }
 inline void pushup(Node *u)
 {
 if(!u->lc->siz) return;
 u->siz=u->lc->siz+u->rc->siz;
 u->val=u->rc->val;
 }
 inline void insert(Node *u,int val)
 {
 if(u->siz==1)
 {
 u->lc=newnode(1,min(u->val,val),null,null);
 u->rc=newnode(1,max(u->val,val),null,null);
 }
 else insert(val > u->lc->val?u->rc:u->lc,val);
 pushup(u);rotate(u);
 }
 inline void erase(Node *u,int val)
 {
 if(u->lc->siz==1&&u->lc->val==val)
 stk[--utot]=u->lc,stk[--utot]=u->rc,*u=*u->rc;
 else if(u->rc->siz==1&&u->rc->val==val)
 stk[--utot]=u->lc,stk[--utot]=u->rc,*u=*u->lc;
 else erase(val > u->lc->val?u->rc:u->lc,val);
 pushup(u);rotate(u);
 }
 inline int rnk(Node *u,int val)
 {
 if(u->siz==1) return val>=u->val;
 return val > u->lc->val ? rnk(u->rc,val)+u->lc->siz : rnk(u->lc,val);
 }
}leafy;

struct Segment_Tree
{
 int mx[maxn],cnt[maxn];
 inline void pushup(int u)
 {
 if(mx[u<<1]==mx[u<<1|1]) mx[u]=mx[u<<1],cnt[u]=cnt[u<<1]+cnt[u<<1|1];
 else if(cnt[u<<1]>cnt[u<<1|1]) mx[u]=mx[u<<1],cnt[u]=cnt[u<<1]-cnt[u<<1|1];
 else mx[u]=mx[u<<1|1],cnt[u]=cnt[u<<1|1]-cnt[u<<1];
 }
 inline void build(int u,int l,int r)
 {
 if(l==r) {mx[u]=a[l],cnt[u]=1;return;}
 int mid=(l+r)>>1;
 build(u<<1,l,mid);build(u<<1|1,mid+1,r);
 pushup(u);
 }
 inline void modify(int u,int l,int r,int x,int val)
 {
 if(l==r) {mx[u]=val;return;}
 int mid=(l+r)>>1;
 if(x<=mid) modify(u<<1,l,mid,x,val);
 else modify(u<<1|1,mid+1,r,x,val);
 pushup(u);
 }
 inline pii query(int u,int l,int r,int x,int y)
 {
 if(x<=l&&r<=y) return make_pair(mx[u],cnt[u]);
 int mid=(l+r)>>1;
 if(y<=mid) return query(u<<1,l,mid,x,y);
 else if(x>mid) return query(u<<1|1,mid+1,r,x,y);
 else
 {
 pii a=query(u<<1,l,mid,x,y),b=query(u<<1|1,mid+1,r,x,y),c;
 if(a.first==b.first) c.first=a.first,c.second=a.second+b.second;
 else if(a.second>b.second) c.first=a.first,c.second=a.second-b.second;
 else c.first=b.first,c.second=b.second-a.second;
 return c;
 }
 }
}seg;

inline void modify(int x,int val)
{
 leafy.erase(leafy.rt[a[x]],x);
 leafy.insert(leafy.rt[val],x);
 seg.modify(1,1,n,x,val);
 a[x]=val;
}

inline int query(int x,int y)
{
 int ans=seg.query(1,1,n,x,y).first;
 if(((y-x+1)>>1)<leafy.rnk(leafy.rt[ans],y)-leafy.rnk(leafy.rt[ans],x-1)) return ans;
 else return -1;
}

template<typename T>
inline void read(T &x)
{
 char c;int f=1;
 while(!isdigit(c=getchar())) (c=='-')&&(f=-1);
 x=c^48;
 while(isdigit(c=getchar())) x=x*10+(c^48);
 x*=f;
}

int main()
{
 int l,r,s,k,m,x;
 for(int i=0;i<maxn*3;++i)
 stk[i]=&utk[i];
 null=new Node(0,0,0,0);
 read(n);read(m);
 for(int i=1;i<=n;++i)
 read(a[i]);
 leafy.init();
 seg.build(1,1,n);
 for(int i=1;i<=n;++i)
 leafy.insert(leafy.rt[a[i]],i);
 while(m--)
 {
 read(l);read(r);read(s);read(k);
 x=query(l,r);
 if(x!=-1) s=x;
 printf("%d\n",s);
 while(k--)
 read(x),modify(x,s);
 }
 printf("%d\n",query(1,n));
 return 0;
}

题解 P4094 【[HEOI2016TJOI2016]字符串】

Wed, 01 Jan 2020 00:00:00 +0000

SAM

怎么题解都没有几篇SAM的，SAM会伤心的。

Part.1

首先观察询问，好像非常不可做，但是可以发现答案有可二分性，具体来说，可以二分最长公共前缀的长度，然后就是询问$c$到$c+mid-1$有没有在$[a,b]$出现过，然而SAM更擅长后缀，所以可以把串翻转过来求后缀匹配数。

如果对SAM敏感的就可以发现这其实就可以发现这是一个在SAM上线段树合并预处理然后倍增跳$parent$树查询的裸题了。

~~于是就完了（不是~~

Part.2

具体来说，我们知道一个$endpos$的父亲肯定是她的后缀，即如果当前点可以匹配，她的父亲肯定可以匹配。SAM上每个点我们都开一棵线段树，统计她可以匹配哪些前缀，首先前缀对应的节点肯定可以匹配自己，然后我们线段树合并答案。

每次假设我们钦定了右端点为$r$，我们就倍增的往上跳到最上面的$r-maxlen+1\le l$的节点，这个点包含了我们所有的需要的东西，直接查一遍即可。

做完了可以去做一下这个，跟这个比较像。

const int maxn=1e5+5;

struct SegmentTree
{
 int lc[maxn*40],rc[maxn*40],wife[maxn*40],cnt;
 void modify(int &u,int l,int r,int x)
 {
 if(!u) u=++cnt;
 ++wife[u];
 if(l==r) return;
 int mid=(l+r)>>1;
 if(x<=mid) modify(lc[u],l,mid,x);
 else modify(rc[u],mid+1,r,x);
 }
 int merge(int u,int v)
 {
 if(!u||!v) return u|v;
 int x=++cnt;
 wife[x]=wife[u]+wife[v];
 lc[x]=merge(lc[u],lc[v]);
 rc[x]=merge(rc[u],rc[v]);
 return x;
 }
 int query(int u,int l,int r,int x,int y)
 {
 if(!u) return 0;
 if(x<=l&&r<=y) return wife[u];
 int mid=(l+r)>>1,res=0;
 if(x<=mid) res+=query(lc[u],l,mid,x,y);
 if(y>mid) res+=query(rc[u],mid+1,r,x,y);
 return res;
 }
}wife;

int tr[maxn<<1][26],maxlen[maxn<<1],link[maxn<<1],cnt=1,las=1,tax[maxn<<1],a[maxn<<1];
int fa[maxn<<1][21],n,pos[maxn],rt[maxn<<1];
char s[maxn];

void insert(int c)
{
 int u=las,nu=las=++cnt;
 maxlen[nu]=maxlen[u]+1;
 for(;u&&!tr[u][c];u=link[u]) tr[u][c]=nu;
 if(!u) return link[nu]=1,void();
 int v=tr[u][c];
 if(maxlen[u]+1==maxlen[v]) return link[nu]=v,void();
 int nv=++cnt;
 maxlen[nv]=maxlen[u]+1;link[nv]=link[v];link[v]=link[nu]=nv;
 memcpy(tr[nv],tr[v],sizeof(tr[v]));
 for(;u&&tr[u][c]==v;u=link[u]) tr[u][c]=nv;
}

inline bool check(int lim,int u,int l,int r)
{
 for(int i=20;i>=0;--i) if(fa[u][i]&&maxlen[fa[u][i]]>=lim) u=fa[u][i];
 return wife.query(rt[u],1,n,l+lim-1,r);
}

int main()
{
 int q,x,y,c,d;
 scanf("%d%d%s",&n,&q,s+1);
 reverse(s+1,s+n+1);
 for(int i=1;i<=n;++i) insert(s[i]-'a'),pos[i]=las,wife.modify(rt[las],1,n,i);
 for(int i=1;i<=cnt;++i) ++tax[maxlen[i]],fa[i][0]=link[i];
 for(int i=1;i<=cnt;++i) tax[i]+=tax[i-1];
 for(int i=cnt;i;--i) a[tax[maxlen[i]]--]=i;
 for(int i=cnt;i>1;--i) rt[link[a[i]]]=wife.merge(rt[a[i]],rt[link[a[i]]]);
 for(int j=1;j<=20;++j)
 for(int i=1;i<=cnt;++i)
 fa[i][j]=fa[fa[i][j-1]][j-1];
 while(q--)
 {
 scanf("%d%d%d%d",&x,&y,&c,&d);
 x=n-x+1;y=n-y+1;c=n-c+1;d=n-d+1;
 int l=0,r=min(x-y+1,c-d+1),mid,ans=0;
 while(l<=r)
 {
 int mid=(l+r)>>1;
 if(check(mid,pos[c],y,x)) l=mid+1,ans=mid;
 else r=mid-1;
 }
 printf("%d\n",ans);
 }
 return 0,QAQ;
}

题解 P4117 【[Ynoi2018]五彩斑斓的世界】第二分块

Wed, 01 Jan 2020 00:00:00 +0000

第二分块，神仙大分块题，不过想清楚了后应该难度相对不太大。

Part.1

先看这题的数据范围$a_i\leq 5e5$，想到分块的方式应该与值域有关。另外我们可以发现，我们的值是只减小不增大的，考虑值域上应该有一个均摊，对每块做一个值域，考虑我们可以在这个上面~~搞一些事情~~做一些操作，使复杂度正确。~~然后我就不会了~~

Part.2

~~看了出题人的题解后~~我们可以发现有一个很有意思的trick，我们考虑值域是不增的，所以我们可以让值域最大值与最小值的差值越来越小。

设当前修改操作有一个$x$，当前最大值为$mx$，我们分两种情况讨论。

$mx \le x\times 2$ 此时我们把$[x+1,mx]$上的值暴力减。
$mx > x\times 2$此时我们把$[1,x]$上的值暴力加，然后打上块整体减的$tag$。

我们每次总是使得块的最大值与最小值越来越近，所以一个块的总复杂的是$O(n)$的，所有块的总复杂度是$O(n\sqrt n)$。

到目前为止，我们解决了最重要的操作。

Part.3

但询问时我们每个块如果只记录当前值在块内出现次数的话，很显然是不行的，因为零散块无法快速找到一个下标对应的现在的答案，所以我们考虑让值域的每个值记录她有哪些下标是当前值。或者换句话，对下标来说，就是用一个指针指向她当前在值域上的值。

我们重新定义两个操作。

$mx \le x\times 2$ 此时我们把$[x+1,mx]$上的值所包含的下标往$[1,x]$合并。
$mx > x\times 2$此时我们把$[1,x]$上的值所包含的下标往$[x+1,x\times 2]$合并，然后打上块整体减的$tag$。

如果是零散块，我们就暴力找出当前下标指向的实际的值，修改后把整个块重构。这样是$O(\sqrt n)$的。

什么样的数据结构能实现这样的操作呢？一个直接的想法就是链表，对每个值维护一个链表，合并是$O(1)$的，满足我们的要求。

然而我们还有一个更高效的数据结构，并查集。我们对每个值维护并查集，合并是$O(1)$的，但在重构块时较链表常数更小，是更优秀的选择。

Part.4

说了这么多，我们还是过不了这道题。~~我没有玩你们~~

仔细观察空间限制，发现是62.50MB，~~果然前面还不够dl~~，我们要考虑一种线性空间的做法，其实很简单，有一个trick叫逐块处理，我们发现每个块对总的时间贡献了$O(n+m)$的复杂度，那么我们对每个块跑一遍所有询问就可以了。

那我们其他那么多题为什么没有用这个trick呢？因为用它要满足下面几个性质。

可以离线，显然我们是离线下来对每个块跑询问。
块之间不互相干扰。如果一个块的信息发生改变就要影响相邻或更多的块，那么就不能用。
答案可加性，我们是每次跑询问是把答案加入总答案，如果不可加，那么也不行。

最后告诉你一个好消息，**这个题不卡常！！！**所以~~快乐的~~$code$吧！~~其实就是细节有点多~~

~~还是贴一下我丑陋的代码吧~~

inline int findf(int x) {return x==fa[x]?x:fa[x]=findf(fa[x]);}

inline void merge(int u,int v)//合并两个值的下标
{
 if(rt[v]) fa[rt[u]]=rt[v];
 else rt[v]=rt[u],to[rt[v]]=v;
 siz[v]+=siz[u];
 rt[u]=siz[u]=0;
}

void build(int x)//新建块
{
 mxval=tag=0;
 for(int i=L[x];i<=R[x];++i)
 {
 mxval=max(mxval,a[i]);
 if(rt[a[i]]) fa[i]=rt[a[i]];
 else rt[a[i]]=fa[i]=i,to[i]=a[i];
 ++siz[a[i]];
 }
}

void restruct(int x,int l,int r,int nx)//重构块
{
 for(int i=L[x];i<=R[x];++i)
 a[i]=to[findf(i)],rt[a[i]]=siz[a[i]]=0,a[i]-=tag;
 for(int i=L[x];i<=R[x];++i)
 to[i]=0;
 l=max(l,L[x]);r=min(r,R[x]);
 for(int i=l;i<=r;++i)
 a[i]=a[i]-(a[i]>nx)*nx;
 build(x);
}

void modify(int nx)//修改
{
 if((nx<<1)<=mxval-tag)
 {
 for(int i=tag+1;i<=tag+nx;++i)
 if(rt[i]) merge(i,i+nx);
 tag+=nx;//记得修改tag
 }
 else
 {
 for(int i=tag+nx+1;i<=mxval;++i)
 if(rt[i]) merge(i,i-nx);
 if(tag+nx<mxval) mxval=tag+nx;//记得更新最大值
 }
}

void query(int x,int i)//询问
{
 int l=q[i].l,r=q[i].r,nx=q[i].x;
 if(nx+tag>5e5) return;
 if(l<=L[x]&&R[x]<=r) ans[i]+=siz[nx+tag];
 else
 {
 l=max(L[x],l);r=min(R[x],r);
 for(int j=l;j<=r;++j)
 if(to[findf(j)]-tag==nx) ++ans[i];
 }
}

int main()
{
 read(n);read(m);
 klen=sqrt(n);
 for(int i=1;i<=n;++i)
 read(a[i]);
 for(int i=1;i<=m;++i)
 read(q[i].opt),read(q[i].l),read(q[i].r),read(q[i].x);
 blocks=(n-1)/klen+1;
 for(int i=1;i<=blocks;++i)
 L[i]=R[i-1]+1,R[i]=i*klen;
 R[blocks]=n;
 for(int i=1;i<=blocks;++i)//先枚举块，逐块处理
 {
 memset(rt,0,sizeof(rt));
 memset(siz,0,sizeof(siz));
 build(i);
 for(int j=1;j<=m;++j)
 {
 if(L[i]>q[j].r||R[i]<q[j].l) continue;
 else if(q[j].opt==1)
 {
 if(q[j].l<=L[i]&&R[i]<=q[j].r)
 modify(q[j].x);
 else restruct(i,q[j].l,q[j].r,q[j].x);
 }
 else query(i,j);
 }
 }
 for(int i=1;i<=m;++i)
 if(q[i].opt==2) printf("%d\n",ans[i]);
 return 0;
}

题解 P4121 【[WC2005]双面棋盘】

Wed, 01 Jan 2020 00:00:00 +0000

线段树分治模板题。

Part.1

Q：如果没有修改，我们怎么做？

A：用并查集维护连通性。

直接扫一遍，我们加进来一个数，就先令答案++，看一下四个方向，如果某个方向与当前点不在同一个连通块中，那么就合并并查集，令答案–。

Part.2

有修改？并查集不支持删除？怎么办？乱搞

这里我们可以请出我们解决这类问题的神器，线段树分治。（没有学过的请左转【模板】线段树分治）

我们知道每个位置在时间轴上有时是0，有时是1，那么对应的就是一段一段的区间，由线段树的性质，每个区间都可以拆成log个小区间，我们只用先在那些位置挂上修改操作，再跑一遍dfs，走到对应点时修改，回退时再撤销即可，走到叶节点时再输出答案即可。

总时间复杂度$O(mlog(n^2+m))$

具体实现可以看代码。

#define Id(x,y) ((x-1)*n+y)
using namespace std;
typedef pair<int,int> pii;
const int maxn=205;
const int dx[]={1,0,-1,0};
const int dy[]={0,1,0,-1};

int mp[maxn][maxn],fa[maxn*maxn],dep[maxn*maxn],n,m,ans[2],pre[maxn][maxn],cnt;
struct Query
{
 int l,r,val,x,y;
}q[maxn*maxn*2];

stack<pii> st;
vector<int> wife[maxn*maxn*4];

template<typename T>
inline void read(T &x)
{
 char c;int f=1;
 while(!isdigit(c=getchar())) (c=='-')&&(f=-1);
 x=c^48;
 while(isdigit(c=getchar())) x=x*10+(c^48);
 x*=f;
}

void modify(int u,int l,int r,int x,int y,int id)
{
 if(x<=l&&r<=y) return void(wife[u].push_back(id));
 int mid=(l+r)>>1;
 if(x<=mid) modify(u<<1,l,mid,x,y,id);
 if(y>mid) modify(u<<1|1,mid+1,r,x,y,id);
}

inline int findf(int x)
{
 while(fa[x]!=x) x=fa[x];
 return x;
}

void merge(int u,int v)
{
 if(u==v) return;
 if(dep[u]>dep[v]) swap(u,v);
 st.push(make_pair(u,dep[u]==dep[v]));
 fa[u]=v;dep[v]+=(dep[u]==dep[v]);
}

void solve(int u,int l,int r)
{
 int siz=st.size(),ans0=ans[0],ans1=ans[1];
 for(const auto &i:wife[u])
 {
 ans[q[i].val]++;
 mp[q[i].x][q[i].y]=q[i].val;
 for(int j=0,pref=0;j<4;++j)
 {
 int tx=q[i].x+dx[j],ty=q[i].y+dy[j];
 if(tx<=0||ty<=0||tx>n||ty>n) continue;
 if(mp[q[i].x][q[i].y]==mp[tx][ty])
 {
 int x=findf(Id(q[i].x,q[i].y)),y=findf(Id(tx,ty));
 if(x==y) continue;
 --ans[q[i].val];merge(x,y);
 }
 }
 }
 if(l==r) printf("%d %d\n",ans[1],ans[0]);
 else
 {
 int mid=(l+r)>>1;
 solve(u<<1,l,mid);solve(u<<1|1,mid+1,r);
 }
 for(const auto &i:wife[u])
 mp[q[i].x][q[i].y]=-1;
 ans[0]=ans0;ans[1]=ans1;
 while(st.size()>siz)
 {
 int x=st.top().first;
 dep[fa[x]]-=st.top().second;
 fa[x]=x;st.pop();
 }
}

int main()
{
 int x,y;
 read(n);
 for(int i=1;i<=n;++i)
 for(int j=1;j<=n;++j)
 read(mp[i][j]);
 read(m);
 for(int i=1;i<=n;++i)
 for(int j=1;j<=n;++j)
 q[Id(i,j)]=(Query){1,m,mp[i][j],i,j},pre[i][j]=Id(i,j);
 for(int i=1;i<=n*n;++i) fa[i]=i;
 cnt=n*n;
 for(int i=1;i<=m;++i)
 {
 read(x);read(y);
 q[pre[x][y]].r=i-1;
 q[++cnt]=(Query){i,m,mp[x][y]^=1,x,y};
 pre[x][y]=cnt;
 }
 for(int i=1;i<=cnt;++i)
 if(q[i].l<=q[i].r) modify(1,1,m,q[i].l,q[i].r,i);
 memset(mp,-1,sizeof(mp));
 solve(1,1,m);
 return 0,qwq;
}

题解 P4212 【外太空旅行】

Wed, 01 Jan 2020 00:00:00 +0000

模拟退火

退火大法吼啊！

首先不知道模拟退火的请左转这个题

然后回到我们的这个问题，实际上我们的这个题是图论中的一类经典问题——最大团问题，这个问题是指在一个图中找一个子图是完全图，使这个子图的点数最多。这是一个NP完全问题~~别说你不知道啥是NP完全~~，一般情况下解决NP完全问题，模拟退火都有较好的表现。

正片开始：

我们先产生一个排列，然后从前往后的枚举点，考虑这个点是否能加入，能就加入，不能就返回答案，这样我们就得到了一个解，然而它不一定使最优解，这个计算函数长这样：

inline int calc(int *a)
{
 for(int i=1;i<=n;++i)
 for(int j=1;j<i;++j)
 if(!e[a[i]][a[j]]) return n-i+1;
 return 0;
}

我们可以每次尝试交换排列中的两个数来退火，就像这样：


void SA()
{
 memcpy(a,b,sizeof(b));
 for(double t=2048;t>1e-18;t*=delta)
 {
 int x=rand()%n+1,y=rand()%n+1;
 if(x==y) continue;
 swap(a[x],a[y]);
 int now=calc(a),D=now-ans;
 if(D<0) ans=now,memcpy(b,a,sizeof(a));
 else if(exp(-D/t)*RAND_MAX<=rand()) swap(a[x],a[y]);
 }
}

多次退火到时间上限：

double pre=clock();
while(clock()-pre<0.95*CLOCKS_PER_SEC) SA();

注意记录一下最优解的排列，每次从那里开始。

然后就没有了。

剩下的就只有~~最有意思的~~调参了。

代码，在$O2$的加持一般有九十分，~~洗一下脸说不定就A了~~

#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <ctime>
using namespace std;
const int maxn=55;
const double delta=0.997;

int a[maxn],e[maxn][maxn],n,ans,b[maxn];

inline int calc(int *a)
{
 for(int i=1;i<=n;++i)
 for(int j=1;j<i;++j)
 if(!e[a[i]][a[j]]) return n-i+1;
 return 0;
}

void SA()
{
 memcpy(a,b,sizeof(b));
 for(double t=2048;t>1e-18;t*=delta)
 {
 int x=rand()%n+1,y=rand()%n+1;
 if(x==y) continue;
 swap(a[x],a[y]);
 int now=calc(a),D=now-ans;
 if(D<0) ans=now,memcpy(b,a,sizeof(a));
 else if(exp(-D/t)*RAND_MAX<=rand()) swap(a[x],a[y]);
 }
}

int main()
{
 srand(time(0));
 int u,v;
 scanf("%d",&n);
 if(n==1) {puts("1");return 0;}
 while(scanf("%d%d",&u,&v)!=EOF)
 e[u][v]=e[v][u]=1;
 for(int i=1;i<=n;++i) b[i]=i;
 ans=calc(b);
 double pre=clock();
 while(clock()-pre<0.95*CLOCKS_PER_SEC) SA();
 printf("%d\n",n-ans);
 return 0,QAQ;
}

题解 P4887 【【模板】莫队二次离线（第十四分块(前体)）】

Wed, 01 Jan 2020 00:00:00 +0000

莫队二次离线

最近学了这个黑科技，来写篇题解分享一下。

顺便$orz\;lxl$

Part.1 问题引入

有一个序列，每次查询一个区间中有几个二元组的的异或值在二进制下有$k$个$1$。

考虑莫队。

先用莫队转化问题，先考虑我们已经求出$[l,r]$的答案，要将$r+1$加入答案，其他的转移类似，现在问题转化为求$r+1$与$[l,r]$中有几个数的异或值有$k$个$1$。

Part.2 暴力

考虑暴力怎么做，由于值域很小$(a_i\leq 16384)$，我们可以先预处理出一个数组$x$中存储有哪些数在二进制数下有$k$个1，每一次插入一个数$a_i$，就把它与$x$数组中所有的数异或起来的值放进一个桶里，然后查询就直接查当前数在桶中出现了几次。为什么呢？

比如我们有$a_i\;xor\;a_j=x$，就有$a_i\;xor\;x=a_j$，我们已经将$a_i\;xor\;x$放入桶里，直接查就可以了。

但这样有个问题，莫队有$n\sqrt n$次转移，每次修改时如果真的暴力插入桶的话，复杂度就是$O(n\sqrt n\times x)$（设$x$为数组中的元素个数），显然是不对的，考虑进一步优化。

Part.3 解决

我们进一步挖掘性质，发现我们要求的是$r+1$对$[l,r]$的贡献，实际上我们可以先求它对$[1,r]$的贡献，再减去$[1,l-1]$的贡献，为什么要这么做呢？我们可以发现$r+1$对前者的贡献是可以$O(n\times x)$是可以预处理的，就只用考虑后者的贡献了。

如下图，我们考虑我们已经算出了红色部分的贡献了。

然后我们需要转移绿色部分的贡献。

这个过程中我们可以发现，左端点是不变，即我们的$[1,l-1]$的答案是不变的，即不用修改，也就是说，我们只有查询操作，而查询操作时$O(1)$的！

所以我们二次离线，先跑一次莫队，将如上的绿色区间保存下来，再统一处理。

具体实现可以每个点开一个$vector$，然后移动右端点的时，我们将如上的绿色区间保存在左端点，移动左端点时，将绿色区间保存在右端点。

然后我们把这些$vector$扫一遍，修改就只有在从$i$到$i+1$时才有，查询还是$O(n\sqrt n)$次，但单次是$O(1)$的。

所以我们的总复杂的就变成了$O(n\sqrt n+n\times x)$！

总结一下，对于那种查询复杂度很高的东西，并且同时询问信息还可以差分的问题，我们就可以用莫队二次离线解决。

做完这题可以去做一下这个，稍微要复杂一点，需要一些其他的数据结构辅助。

这个算法理解其实并不难，主要是代码细节比较多，建议尽量先自己实现，遇到问题再看题解的代码。

struct Query_Node
{
 int l,r,id,kl;
 ll ans;
 bool operator < (const Query_Node &u) const{
 return kl!=u.kl?kl<u.kl:(kl&1?r<u.r:r>u.r);
 }
}q[maxn];

struct Node
{
 int l,r,id;
 Node(int l=0,int r=0,int id=0) : l(l),r(r),id(id) {}
};
ll ans[maxn];
vector<Node> two[maxn];
int n,m,k,a[maxn],tax[maxn],klen,pre[maxn];
int isu[maxn],ist;

inline int calc(int x)
{
 int ans=0;
 while(x) ++ans,x-=(x&(-x));
 return ans;
}

template<typename T>
inline void read(T &x)
{
 char c;int f=1;
 while(!isdigit(c=getchar())) (c=='-')&&(f=-1);
 x=c^48;
 while(isdigit(c=getchar())) x=x*10+(c^48);
 x*=f;
}

int main()
{
 read(n);read(m);read(k);
 for(int i=1;i<=n;++i)
 read(a[i]);
 klen=n/sqrt(m*2/3);
 for(int i=1;i<=m;++i)
 {
 read(q[i].l);read(q[i].r);q[i].id=i;
 q[i].kl=(q[i].l-1)/klen+1;
 }
 sort(q+1,q+m+1);
 for(int i=0;i<=maxa;++i) if(calc(i)==k) isu[++ist]=i;
 for(int i=1;i<=n;++i)
 {
 for(int j=1;j<=ist;++j) ++tax[isu[j]^a[i]];
 pre[i]=tax[a[i+1]];
 }
 for(int i=1,l=1,r=0;i<=m;++i)//先空跑莫队，找出绿色区间，同时处理前者的贡献
 {
 if(l<q[i].l) two[r].push_back(Node(l,q[i].l-1,-i));
 while(l<q[i].l) q[i].ans+=pre[l-1],++l;
 if(l>q[i].l) two[r].push_back(Node(q[i].l,l-1,i));
 while(l>q[i].l) q[i].ans-=pre[l-2],--l;
 if(r<q[i].r) two[l-1].push_back(Node(r+1,q[i].r,-i));
 while(r<q[i].r) q[i].ans+=pre[r],++r;
 if(r>q[i].r) two[l-1].push_back(Node(q[i].r+1,r,i));
 while(r>q[i].r) q[i].ans-=pre[r-1],--r;
 }
 memset(tax,0,sizeof(tax));
 //二次离线，处理后者的贡献
 for(int i=1;i<=n;++i)
 {
 for(int j=1;j<=ist;++j) ++tax[isu[j]^a[i]];
 for(vector<Node>::iterator it=two[i].begin();it!=two[i].end();++it)
 for(int j=it->l;j<=it->r;++j)
 {
 int tmp=tax[a[j]];
 if(j<=i&&k==0) tmp--;
 if(it->id<0) q[-it->id].ans-=tmp;
 else q[it->id].ans+=tmp;
 }
 }
 for(int i=1;i<=m;++i) q[i].ans+=q[i-1].ans,ans[q[i].id]=q[i].ans;
 for(int i=1;i<=m;++i)
 printf("%lld\n",ans[i]);
 return 0;
}

题解 P5048 【[Ynoi2019模拟赛]Yuno loves sqrt technology III】

Wed, 01 Jan 2020 00:00:00 +0000

其实本蒟蒻自己想了一会后便有了一些思路，但实现方面还是还是~~学习了~~$\text{dllxl}$的做法的

强制在线导致一些离线做法没有办法解决（如莫队），我们考虑分块，预处理出第l到第r个块的众数次数，再把零散块的数一个一个更新答案。

我们用一个vector存某个值的下标序列，设当前答案是ans，如果当前点在左边，它的后ans+1个元素在r内，则更新答案，右边则反之。

~~然而今天我是来教大家卡常的~~

关于这个题的提交记录~~真的卡的我心态爆炸~~

~~好像交了一次题解都没过？~~ ~~不要封我~~

好了，正文开始，首先了解一下这个火车头

#pragma GCC diagnostic error "-std=c++14"
#pragma GCC target("avx")
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")

这是个好东西，可以让你$n^2$过百万（雾

但加了这个好像还是T完了？

没事，我们还有IO优化

下面是我窃了机房大佬的IO优化

namespace quick {
#define tp template<typename Type>
 namespace in {
 inline char getc() {
 static char buf[1<<21],*p1=buf,*p2=buf;
 return p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++;
 }
 inline int read(char *s) {
 *s=getc();
 while(isspace(*s)) {*s=getc();if(*s==EOF) return 0;}
 while(!isspace(*s)&&*s!=EOF) {s++;*s=getc();}
 *s='\0'; return 1;
 }
 tp inline int read(Type &x) {
 x=0;bool k=false;char c=getc();
 while(!isdigit(c)) {k|=(c=='-');c=getc();if(c==EOF) return 0;}
 while(isdigit(c)) {x=(x<<1)+(x<<3)+(c^48);c=getc();}
 x*=(k?-1:1); return 1;
 }
 template <typename Type,typename... Args>
 inline int read(Type &t,Args &...args) {
 int res=0;
 res+=read(t);res+=read(args...);
 return res;
 }
 }
 using in::read;
 namespace out {
 char buf[1<<21];int p1=-1;const int p2=(1<<21)-1;
 inline void flush() {
 fwrite(buf,1,p1+1,stdout);
 p1=-1;
 }
 inline void putc(const char &c) {
 if(p1==p2) flush();
 buf[++p1]=c;
 }
 inline void write(char *s) {
 while(*s!='\0') putc(*s),s++;
 }
 tp inline void write(Type x) {
 static char buf[30];int p=-1;
 if(x<0) {putc('-');x=-x;}
 if(x==0) putc('0');
 else for(;x;x/=10) buf[++p]=x%10+48;
 for(;p!=-1;p--) putc(buf[p]);
 }
 inline void write(char c) {putc(c);}
 template <typename Type,typename... Args>
 inline void write(Type t,Args ...args) {
 write(t);write(args...);
 }
 }
 using out::write;
 using out::flush;
 tp inline Type max(const Type a,const Type b) {
 if(a<b) return b;
 return a;
 }
 tp inline Type min(const Type a,const Type b) {
 if(a<b) return a;
 return b;
 }
 tp inline void swap(Type &a,Type &b) {
 a^=b^=a^=b;
 }
 tp inline Type abs(const Type a) {
 return a>=0?a:-a;
 }
#undef tp
}
using namespace quick;

直接read，write就ok了

还有一个很关键很关键的优化（敲黑板

这是我们在计算第i个块到第j个块的代码，$\text{kmx[][]}$就是那个数组，tot是块总数。

 for(int i=1;i<=tot;++i)
 {
 for(int j=i;j<=tot;++j)
 {
 kmx[i][j]=kmx[i][j-1];
 for(int k=kn[j-1]+1;k<=kn[j];++k)
 kmx[i][j]=max(kmx[i][j],++vis[al[k]]);
 }
 memset(vis,0,sizeof(vis));
 }

但我们可以发现第一个块与最后一个块根本用不上，所以可以改成

 for(int i=2;i<tot;++i)
 {
 for(int j=i;j<tot;++j)
 {
 kmx[i][j]=kmx[i][j-1];
 for(int k=kn[j-1]+1;k<=kn[j];++k)
 kmx[i][j]=max(kmx[i][j],++vis[al[k]]);
 }
 memset(vis,0,sizeof(vis));
 }

大约可以快0.1s。

还有要用memset，它绝对比其他方式都快（至少这个题是的）。

还有max不要用STL，自己手写要快一点。

~~还有lxl是真的dio~~

完整代码

#pragma GCC diagnostic error "-std=c++14"
#pragma GCC target("avx")
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <cstring>
using namespace std;
const int mxn=708,maxn=5e5+5,smxn=maxn/mxn+5;

int n,len,kn[smxn],tot;
int kmx[smxn][smxn],bel[maxn];
int iskn[maxn];
int al[maxn];
int a[maxn],b[maxn],m;
int vis[maxn],vps[maxn];
vector<int> pos[maxn];

namespace quick {
#define tp template<typename Type>
 namespace in {
 inline char getc() {
 static char buf[1<<21],*p1=buf,*p2=buf;
 return p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++;
 }
 inline int read(char *s) {
 *s=getc();
 while(isspace(*s)) {*s=getc();if(*s==EOF) return 0;}
 while(!isspace(*s)&&*s!=EOF) {s++;*s=getc();}
 *s='\0'; return 1;
 }
 tp inline int read(Type &x) {
 x=0;bool k=false;char c=getc();
 while(!isdigit(c)) {k|=(c=='-');c=getc();if(c==EOF) return 0;}
 while(isdigit(c)) {x=(x<<1)+(x<<3)+(c^48);c=getc();}
 x*=(k?-1:1); return 1;
 }
 template <typename Type,typename... Args>
 inline int read(Type &t,Args &...args) {
 int res=0;
 res+=read(t);res+=read(args...);
 return res;
 }
 }
 using in::read;
 namespace out {
 char buf[1<<21];int p1=-1;const int p2=(1<<21)-1;
 inline void flush() {
 fwrite(buf,1,p1+1,stdout);
 p1=-1;
 }
 inline void putc(const char &c) {
 if(p1==p2) flush();
 buf[++p1]=c;
 }
 inline void write(char *s) {
 while(*s!='\0') putc(*s),s++;
 }
 tp inline void write(Type x) {
 static char buf[30];int p=-1;
 if(x<0) {putc('-');x=-x;}
 if(x==0) putc('0');
 else for(;x;x/=10) buf[++p]=x%10+48;
 for(;p!=-1;p--) putc(buf[p]);
 }
 inline void write(char c) {putc(c);}
 template <typename Type,typename... Args>
 inline void write(Type t,Args ...args) {
 write(t);write(args...);
 }
 }
 using out::write;
 using out::flush;
 tp inline Type max(const Type a,const Type b) {
 if(a<b) return b;
 return a;
 }
 tp inline Type min(const Type a,const Type b) {
 if(a<b) return a;
 return b;
 }
 tp inline void swap(Type &a,Type &b) {
 a^=b^=a^=b;
 }
 tp inline Type abs(const Type a) {
 return a>=0?a:-a;
 }
#undef tp
}
using namespace quick;

inline int max(const int &a,const int &b)
{
 return a>b?a:b;
}

int main()
{
 int t,pre=0;
 read(n,t);
 for(int i=1;i<=n;++i)
 read(a[i]),b[i]=a[i];
 tot=(n-1)/mxn+1;
 for(int i=1;i<=tot;++i)
 kn[i]=kn[i-1]+tot;
 kn[tot]=n;
 // tot=(n-1)/mxn+1;
 // for(int i=1;i<=tot;++i)
 // kn[i]=kn[i-1]+mxn;
 // kn[tot]=n;
 for(int i=1;i<=tot;++i)
 for(int j=kn[i-1]+1;j<=kn[i];++j)
 bel[j]=i;
 sort(b+1,b+n+1);
 m=unique(b+1,b+n+1)-b-1;
 for(int i=1;i<=n;++i)
 al[i]=lower_bound(b+1,b+m+1,a[i])-b;
 for(int i=2;i<tot;++i)
 {
 for(int j=i;j<tot;++j)
 {
 kmx[i][j]=kmx[i][j-1];
 for(int k=kn[j-1]+1;k<=kn[j];++k)
 kmx[i][j]=max(kmx[i][j],++vis[al[k]]);
 }
 memset(vis,0,sizeof(vis));
 }
 for(int i=1;i<=n;++i)
 {
 pos[al[i]].push_back(i);
 vps[i]=pos[al[i]].size()-1;
 }
 int l,r;
 while(t--)
 {
 read(l,r);
 l^=pre;r^=pre;
 int pl=bel[l],pr=bel[r];
 if(pl==pr)
 {
 int nowans=0;
 for(int i=l;i<=r;++i)
 nowans=max(nowans,++vis[al[i]]);
 for(int i=l;i<=r;++i)
 vis[al[i]]=0;
 write(nowans,'\n');
 pre=nowans;
 }
 else
 {
 int nowans=kmx[pl+1][pr-1];
 for(int i=l;i<=kn[pl];++i)
 {
 int siz=pos[al[i]].size();
 while(vps[i]+nowans<siz&&pos[al[i]][vps[i]+nowans]<=r) ++nowans;
 }
 for(int i=kn[pr-1]+1;i<=r;++i)
 while(vps[i]-nowans>=0&&pos[al[i]][vps[i]-nowans]>=l) ++nowans;
 write(nowans,'\n');
 pre=nowans;
 }
 }
 flush();
 return 0;
}

后记

首先我的代码不一定在全天候都能过（但你凌晨交是肯定能过），另外如果你认真读了我的代码，你就会发现我用的是固定块长mxn=708，但我在初始化块的时候是这么写的

 tot=(n-1)/mxn+1;
 for(int i=1;i<=tot;++i)
 kn[i]=kn[i-1]+tot;
 kn[tot]=n;

kn是块的右端点，实际上应是

 tot=(n-1)/mxn+1;
 for(int i=1;i<=tot;++i)
 kn[i]=kn[i-1]+mxn;
 kn[tot]=n;

但上面的写法竟然AC了，而且比下面的快，~~这也算玄学卡常吗~~

希望有大佬能解释

完结撒花！

题解 P5073 【[Ynoi2015]世上最幸福的女孩】

Wed, 01 Jan 2020 00:00:00 +0000

如果你其他$\text{Ynoi}$还没有刷完建议不要来刷这道题，因为：

实际上，这是一道正宗的计算几何题。

Part.1

没什么好说的，既然都知道这是一道计算几何题，请先自行学习计算几何的基础知识。

你需要掌握的有：向量的加，减，叉积，凸包的求法（极角排序）。

以下是下文中点（或向量）的定义：

struct Point //点
{
 ll x,y;
 Point(ll x=0,ll y=0) : x(x),y(y) {}
 Point operator + (const Point &a) const {return Point(x+a.x,y+a.y);} //加
 Point operator - (const Point &a) const {return Point(x-a.x,y-a.y);} //减
 ll operator * (const Point &a) const {return x*a.y-y*a.x;} //叉积
};

凸包的定义：

struct Hull //凸包
{
 Point *st;
 int now,top;
 Point& operator [] (const int &x) const {return st[x];}
 inline void insert(const Point &a) const{st[a.x].y=max(st[a.x].y,a.y);} //更新最优点
 inline void push(const Point &a) {st[++top]=a;} //加入一个点
 inline void init(int x) //预处理，长度为x的答案对应其位置，方便insert
 {
 for(int i=1;i<=x;++i)
 st[i]=Point(i,-inf);
 top=x;
 }
 inline void Convex() //求新凸包
 {
 if(top<=2) return;
 int lim=top;top=2;
 for(int i=3;i<=lim;++i)
 {
 if(st[i].y==-inf) continue;
 while(top>1&&(st[top]-st[top-1])*(st[i]-st[top-1])>=0) --top;
 st[++top]=st[i];
 }
 }
 inline ll Getnow()
 {
 while(now!=top&&add*st[now].x+st[now].y<add*st[now+1].x+st[now+1].y) ++now; //离线保证单增，移动指针即可
 return st[now].x*add+st[now].y;
 }
};

看不懂可以先跳过，下面要用了再来看，主要一些小函数下面可能没有讲。

这个题的的新知识有：闵可夫斯基和合并凸包。

问题：给你两个点集A,B，产生一个新点集C,满足对任意点$(x_1,y_1)\in A$，$(x_2,y_2)\in B$，得到一个$(x_1+x_2,y_1+y_2)\in C$。

然后知道A，B的凸包，求C的凸包。

~~这不是很简单吗，暴力枚举直接做。~~

我们需要一个复杂度为$O(n)$的算法。

我们画个图手玩一下，发现新的凸包就是原来的两个凸包的边重新极角排序一边（网上有图我就不放了）。

~~证明我不会，可以看一下这个题，感性理解一下，毕竟这里是讲数据结构的。~~

于是我们得到了一个很有用的结论，求凸包只需要求原来的凸包，然后在一起重新排序就可以了。

但直接重排有点浪费，由于原来两个凸包都已经求好了，于是可以类似归并排序，重新归并一次，代码如下：

inline void Minkowski(Hull &c,Hull &a,Hull &b) //闵可夫斯基和合并凸包
{
 int i=1,j=1;c.insert(a[1]+b[1]);
 while(i!=a.top&&j!=b.top)
 {
 ((a[i+1]-a[i])*(b[j+1]-b[j])<0)?++i:++j;
 c.insert(a[i]+b[j]);
 }
 while(i!=a.top) ++i,c.insert(a[i]+b[j]);
 while(j!=b.top) ++j,c.insert(a[i]+b[j]);
}

凸包存的是点，我们比较a中当前的边与b中当前的边，看一下谁角度更小，然后加入即可，且加入点的原来的点的和。

~~很简单是不是？~~

下面开始我们今天的数据结构部分。

Part.2

最大子段和？

很简单啊，$O(n)$扫一遍。

区间最大子段和，单点修改？

做过小白逛公园的都知道（没做过还来$\text{Ynoi}$）这是一个经典问题。~~哪来那么多经典问题~~

线段树。

每个点维护一个$lmx,rmx,mmx,sum$，即最大左子段和，最大右子段和，最大子段和，区间和。

合并很简单吧（默认大家都会）。

一个封装好的结构体长这样：

struct Node //答案节点
{
 ll lmx,rmx,mmx,sum;
 Node(ll lmx,ll rmx,ll mmx,ll sum) : lmx(lmx),rmx(rmx),mmx(mmx),sum(sum) {}
 Node() {}
 Node operator + (const Node &x) const
 {
 return Node(max(lmx,sum+x.lmx),max(x.rmx,x.sum+rmx),max(rmx+x.lmx,max(mmx,x.mmx)),sum+x.sum);
 }
};

下面的重载运算符即是合并两个答案。

时间复杂度$O(nlogn)$

区间最大子段和，全局加？

先考虑打标记。

~~显然不行~~

主要原因是无法通过新的标记快速更新线段树的节点。

~~然后就没法做？~~

换个思路。

Part.3

线段树的四个信息肯定还是必须要维护的。

$sum$照旧维护。

我们考虑对于维护长度为$x$的$lmx,rmx,mmx$，实际上这就是一些二维点$(x,ans(x))$

我们可以发现，当我们给这个节点整体加了一个数$add$，那么$ans(x)$就变成了$ans(x)+x*add$，但显然对于我们的这些二维的点，肯定只有一部分是有用的，如果一个点被另一个点压制，那么它就肯定没有用。那么哪些点是有用的呢？相信看到这里大概都明白了，实际上就是这些点的凸包上的点。

所以我们改成维护$lmx,rmx,mmx$三个凸包。

Part.4

首先先解决$lmx,rmx$两个凸包，由于两个等价，只考虑$lmx$。

先看一下我们原来的$lmx$的转移方程

lmx[u]=max(lmx[u<<1],sum[u<<1]+lmx[u<<1|1]);

改成凸包后，我们就是先给右儿子的$lmx$凸包加上一个点$(len_{lson},sum_{lson})$，然后与右凸包合并，代码长这样：

 inline void merge(Hull &c,Hull &a,Hull &b,const Point &now) //合并前后缀的凸包
 {
 for(int i=1;i<=a.top;++i) c.push(a[i]);
 for(int i=1;i<=b.top;++i) c.push(b[i]+now);
 c.Convex(); //求新凸包
 }

$now$就是$(len_{lson},sum_{lson})$，代码就是先把两个凸包加进去，然后求新凸包。

inline void Convex() //求新凸包
{
 if(top<=2) return;
 int lim=top;top=2;
 for(int i=3;i<=lim;++i)
 {
 if(st[i].y==-inf) continue;
 while(top>1&&(st[top]-st[top-1])*(st[i]-st[top-1])>=0) --top;
 st[++top]=st[i];
 }
}

由于原来就有序，所以可以直接求不用排序。

注意$st$数组中始终$top\le i$，所以可以不用辅助空间。

Part.5

观察$mmx$的转移方程：

mmx[u]=max(max(mmx[u<<1],mmx[u<<1|1]),rmx[u<<1]+lmx[u<<1|1]);

对于$mmx$的凸包，我们先用左右儿子的$mmx$更新一下：

mmx[u].st++;mmx[u].init(r-l+1);
for(int i=1;i<=mmx[u<<1].top;++i) mmx[u].insert(mmx[u<<1][i]);
for(int i=1;i<=mmx[u<<1|1].top;++i) mmx[u].insert(mmx[u<<1|1][i]);

然后$lmx[u<<1]+rmx[u<<1|1]$，怎么处理呢？

是不是觉得还有什么没有登场？

没错，我们的闵可夫斯基和！

仔细想一想，假设有$(x_1,ans(x_1))\in lmx[u<<1]\;\;(x_2,ans(x_2))\in rmx[u<<1|1]$，就会得到一个新的点$x_1+x_2,ans(x_1+x_2))\in mmx[u]$！

于是我们一次闵可夫斯基和合并凸包就可以了，代码长这样：

inline void Minkowski(Hull &c,Hull &a,Hull &b) //闵可夫斯基和合并凸包
{
 int i=1,j=1;c.insert(a[1]+b[1]);
 while(i!=a.top&&j!=b.top)
 {
 ((a[i+1]-a[i])*(b[j+1]-b[j])<0)?++i:++j;
 c.insert(a[i]+b[j]);
 }
 while(i!=a.top) ++i,c.insert(a[i]+b[j]);
 while(j!=b.top) ++j,c.insert(a[i]+b[j]);
}

然后就完了。

Part.6

~~不还没完~~

我们光求了一堆凸包，怎么用啊？

这还不简单，直接在凸包上二分即可。

然而你仔细想想，这样的复杂度是多少？

$O(nlog^2n)$

由于这是$\text{Ynoi}$，不是让你$AC$的地方，所以你需要优化。

怎么优化？

我们考虑离线，想一想，凸包有一个好的性质，它上面的点是单调的，我们可以知道从一开始到这个点一共全局加了多少，然后我们按这个把询问排序，由于我们加的值是单增的，所以我们直接每次从上次的位置开始向右扫凸包，因为答案绝对不可能向前走，所以我们的均摊时间就变成了$O(nlogn)$。

~~于是你就可以快乐的去$AC$此题了！~~

具体实现借鉴了shadowice1984大佬的方法，把同一层的线段树节点空间分配在一起，减小访问压力。

凸包使用了指针，也可以用$vector$。

$\text{Code}$

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn=3e5+5;
const ll inf=0x3f3f3f3f3f3f3f3f;

ll add,a[maxn];
int n,m;

struct Point //点
{
 ll x,y;
 Point(ll x=0,ll y=0) : x(x),y(y) {}
 Point operator + (const Point &a) const {return Point(x+a.x,y+a.y);} //加
 Point operator - (const Point &a) const {return Point(x-a.x,y-a.y);} //减
 ll operator * (const Point &a) const {return x*a.y-y*a.x;} //叉积
};

struct Hull //凸包
{
 Point *st;
 int now,top;
 Point& operator [] (const int &x) const {return st[x];}
 inline void insert(const Point &a) const{st[a.x].y=max(st[a.x].y,a.y);} //更新最优点
 inline void push(const Point &a) {st[++top]=a;} //加入一个点
 inline void init(int x) //预处理，长度为x的答案对应其位置，方便insert
 {
 for(int i=1;i<=x;++i)
 st[i]=Point(i,-inf);
 top=x;
 }
 inline void Convex() //求新凸包
 {
 if(top<=2) return;
 int lim=top;top=2;
 for(int i=3;i<=lim;++i)
 {
 if(st[i].y==-inf) continue;
 while(top>1&&(st[top]-st[top-1])*(st[i]-st[top-1])>=0) --top;
 st[++top]=st[i];
 }
 }
 inline ll Getnow()
 {
 while(now!=top&&add*st[now].x+st[now].y<add*st[now+1].x+st[now+1].y) ++now; //离线保证单增，移动指针即可
 return st[now].x*add+st[now].y;
 }
};

struct Node //答案节点
{
 ll lmx,rmx,mmx,sum;
 Node(ll lmx,ll rmx,ll mmx,ll sum) : lmx(lmx),rmx(rmx),mmx(mmx),sum(sum) {}
 Node() {}
 Node operator + (const Node &x) const
 {
 return Node(max(lmx,sum+x.lmx),max(x.rmx,x.sum+rmx),max(rmx+x.lmx,max(mmx,x.mmx)),sum+x.sum);
 }
};

struct SegmentTree //线段树
{
 Point lmx_base[20][maxn<<1],rmx_base[20][maxn<<1],mmx_base[20][maxn<<1];
 Point *lmx_top[20],*rmx_top[20],*mmx_top[20];
 Hull lmx[maxn<<2],rmx[maxn<<2],mmx[maxn<<2]; //凸包维护可能的答案
 ll sum[maxn<<2];
 SegmentTree()
 {
 for(int i=0;i<20;++i)
 lmx_top[i]=lmx_base[i],rmx_top[i]=rmx_base[i],mmx_top[i]=mmx_base[i];
 }
 inline void merge(Hull &c,Hull &a,Hull &b,const Point &now) //合并前后缀的凸包
 {
 for(int i=1;i<=a.top;++i) c.push(a[i]);
 for(int i=1;i<=b.top;++i) c.push(b[i]+now);
 c.Convex(); //求新凸包
 }
 inline void Minkowski(Hull &c,Hull &a,Hull &b) //闵可夫斯基和合并凸包
 {
 int i=1,j=1;c.insert(a[1]+b[1]);
 while(i!=a.top&&j!=b.top)
 {
 ((a[i+1]-a[i])*(b[j+1]-b[j])<0)?++i:++j;
 c.insert(a[i]+b[j]);
 }
 while(i!=a.top) ++i,c.insert(a[i]+b[j]);
 while(j!=b.top) ++j,c.insert(a[i]+b[j]);
 }
 void build(int u,int l,int r,int dep=0)
 {
 lmx[u].st=lmx_top[dep];rmx[u].st=rmx_top[dep];mmx[u].st=mmx_top[dep];
 if(l==r)
 {
 lmx[u][1]=rmx[u][1]=mmx[u][1]=Point(0,0); //不选则为0
 lmx[u][2]=rmx[u][2]=mmx[u][2]=Point(1,a[l]);sum[u]=a[l];
 lmx[u].top=rmx[u].top=mmx[u].top=2;
 }
 else
 {
 int mid=(l+r)>>1;
 build(u<<1,l,mid,dep+1);build(u<<1|1,mid+1,r,dep+1);
 sum[u]=sum[u<<1]+sum[u<<1|1]; //维护和
 merge(lmx[u],lmx[u<<1],lmx[u<<1|1],Point(mid-l+1,sum[u<<1]));
 merge(rmx[u],rmx[u<<1|1],rmx[u<<1],Point(r-mid,sum[u<<1|1])); //合并前后缀凸包
 mmx[u].st++;mmx[u].init(r-l+1); //为不选预留位置
 for(int i=1;i<=mmx[u<<1].top;++i) mmx[u].insert(mmx[u<<1][i]);
 for(int i=1;i<=mmx[u<<1|1].top;++i) mmx[u].insert(mmx[u<<1|1][i]);
 Minkowski(mmx[u],rmx[u<<1],lmx[u<<1|1]); //合并子段和凸包
 mmx[u].st--;mmx[u][1]=Point(0,0);mmx[u].top++;mmx[u].Convex(); //不选则为0
 }
 lmx[u].now=rmx[u].now=mmx[u].now=1;
 lmx_top[dep]=lmx[u].st+lmx[u].top;
 rmx_top[dep]=rmx[u].st+rmx[u].top;
 mmx_top[dep]=mmx[u].st+mmx[u].top;
 }
 Node query(int u,int l,int r,int x,int y)
 {
 if(x<=l&&r<=y) return Node(lmx[u].Getnow(),rmx[u].Getnow(),mmx[u].Getnow(),sum[u]+(r-l+1)*add);
 int mid=(l+r)>>1;
 if(y<=mid) return query(u<<1,l,mid,x,y);
 if(x>mid) return query(u<<1|1,mid+1,r,x,y);
 return query(u<<1,l,mid,x,y)+query(u<<1|1,mid+1,r,x,y);
 }
}wife;

struct Query
{
 int l,r,id;
 ll val;
 Query(int l=0,int r=0,int id=0,ll val=0) : l(l),r(r),id(id),val(val) {}
 bool operator < (const Query &x) const {return val<x.val;}
}q[maxn<<1];
int tot;
ll ans[maxn<<1];

template<typename T>
inline void read(T &x)
{
 char c;int f=1;
 while(!isdigit(c=getchar())) (c=='-')&&(f=-1);
 x=c^48;
 while(isdigit(c=getchar())) x=x*10+(c^48);
 x*=f;
}

int main()
{
 read(n);read(m);
 for(int i=1;i<=n;++i) read(a[i]);
 for(int i=1,opt,l,r;i<=m;++i)
 {
 read(opt);read(l);
 if(opt==1) add+=l;
 else read(r),++tot,q[tot]=Query(l,r,tot,add);
 }
 sort(q+1,q+tot+1);
 add=q[1].val;
 for(int i=1;i<=tot;++i) q[i].val-=add;
 for(int i=1;i<=n;++i) a[i]+=add; //这里使得所有的q[i].val均为正整数
 wife.build(1,1,n);
 for(int i=1;i<=tot;++i)
 add=q[i].val,ans[q[i].id]=wife.query(1,1,n,q[i].l,q[i].r).mmx;
 for(int i=1;i<=tot;++i)
 printf("%lld\n",ans[i]);
 return 0,QAQ;
}

~~做完了珂以去做一下这个（不是~~

题解 P5217 【贫穷】

Wed, 01 Jan 2020 00:00:00 +0000

看完题目我们都知道是平衡树，而且是要资瓷区间操作的平衡树，并且要能区间翻转，所以我们被迫选择~~自带三倍大常数~~的$Splay$，剩下的都是一些平衡树的基操了。

操作$1$ ：插入，很简单。~~该怎么插就怎么插~~

操作$2$ ：删除，直接删除。

操作$3$ ：翻转，将要操作的子树旋转出来，然后直接打标记翻转。

操作$4$ ：开始时将整个序列$build$出来，然后用数组将原序列在平衡树中的位置记录下来。平衡树中的一个点被删除后就给那个点打上标记，查询时直接查对应的位置，如果被删除后就输出$0$，否则先$dfs$将路上的标记$pushdown$下来，然后再旋转到根输出排名即可。

操作$5$ ：第$k$小，直接输出即可。

操作$6$ ：状压压字母，将要操作的子树旋转出来，然后直接输出。

细节

$1.$

推荐使用一个这样的函数：

inline int split(int l,int r)
{
 int x=rnk(l-1),y=rnk(r+1);
 splay(x,0);splay(y,x);
 return lc(y);
}

$rnk$就是找第$k$个位置。

然后你要插入就

int u=split(pos,pos-1);

删除就

int u=split(pos,pos);

找区间就

int u=split(l,r);

$2.$

为了不使我们$split$时越界，我们就在首尾搞两个字母，然后要把读入后的位置$++$。

然后呢？然后就完了。

上代码：


inline int ids(int u) {return u==rc(fc(u));}
inline void connect(int u,int f,int s) {fc(u)=f;tr[f].ch[s]=u;}
inline void pushup(int u)
{
 if(!u) return;
 tr[u].siz=tr[lc(u)].siz+tr[rc(u)].siz+1;
 tr[u].valt=tr[lc(u)].valt|tr[rc(u)].valt|(1<<tr[u].val);
}
inline void update(int u)
{
 tr[u].rev^=1;
 swap(lc(u),rc(u));
}

inline void pushdown(int u)
{
 if(!tr[u].rev) return;
 if(lc(u)) update(lc(u));
 if(rc(u)) update(rc(u));
 tr[u].rev=0;
}

inline void rotate(int u)
{
 int f=fc(u),ff=fc(f),s1=ids(u),s2=ids(f);
 connect(tr[u].ch[s1^1],f,s1);connect(f,u,s1^1);connect(u,ff,s2);
 pushup(f);pushup(u);
}

inline void splay(int u,int to)
{
 while(fc(u)!=to)
 {
 if(fc(fc(u))==to) rotate(u);
 else if(ids(u)==ids(fc(u))) rotate(fc(u)),rotate(u);
 else rotate(u),rotate(u);
 }
}

inline int rnk(int k)
{
 int u=root;
 while(u)
 {
 pushdown(u);
 if(tr[lc(u)].siz+1==k) return u;
 else if(tr[lc(u)].siz>=k) u=lc(u);
 else k=k-tr[lc(u)].siz-1,u=rc(u);
 }
}

inline int split(int l,int r)
{
 int x=rnk(l-1),y=rnk(r+1);
 splay(x,0);splay(y,x);
 return lc(y);
}

inline void insert(int pos,int val)
{
 split(pos,pos-1);
 int u=rc(root),v=++utot;lc(u)=v;
 tr[v].siz=1;tr[v].fa=u;tr[v].val=val;tr[v].valt=(1<<val);
 pushup(u);pushup(fc(u));pushup(fc(fc(u)));
}

inline void erase(int pos)
{
 int u=split(pos,pos);delt[u]=1;
 lc(fc(u))=0;fc(u)=0;
}

inline void reverse(int l,int r)
{
 int u=split(l,r);
 update(u);
}

void prepush(int u)
{
 if(!u) return;
 prepush(fc(u));pushdown(u);
}

inline int getpos(int pos)
{
 if(delt[used[pos]]) return 1;
 const int &u=used[pos];
 prepush(u);splay(u,0);
 return tr[lc(u)].siz+1;
}

inline int getcol(int l,int r)
{
 int u=split(l,r),res=0;u=tr[u].valt;
 while(u) res++,u=u-(u&(-u));
 return res;
}

int build(int l,int r,int f)
{
 if(l>r) return 0;
 int mid=(l+r)>>1,u=++utot;
 fc(u)=f;used[mid]=u;tr[u].siz=1;
 if(mid!=1&&mid!=n+2) tr[u].val=pre[mid]-'a',tr[u].valt=1<<tr[u].val;
 lc(u)=build(l,mid-1,u);
 rc(u)=build(mid+1,r,u);
 pushup(u);
 return u;
}

template<typename T>
inline void read(T &x)
{
 char c;int f=1;
 while(!isdigit(c=getchar())) (c=='-')&&(f=-1);
 x=c^48;
 while(isdigit(c=getchar())) x=x*10+(c^48);
 x*=f;
}

int main()
{
 int x,y,t;
 char in[10],opt[10];
 read(n);read(t);
 scanf("%s",pre+2);
 root=build(1,n+2,root);
 while(t--)
 {
 scanf("%s",opt);read(x);x++;
 if(opt[0]=='I') scanf("%s",in),insert(x+1,in[0]-'a');
 else if(opt[0]=='D') erase(x);
 else if(opt[0]=='R') read(y),y++,reverse(x,y);
 else if(opt[0]=='P') printf("%d\n",getpos(x)-1);
 else if(opt[0]=='T') printf("%c\n",(char)tr[rnk(x)].val+'a');
 else read(y),y++,printf("%d\n",getcol(x,y));
 }
 return 0;
}

题解 P5314 【[Ynoi2011]ODT】

Wed, 01 Jan 2020 00:00:00 +0000

一道卡常好题。

我们考虑暴力做法，我们就可以直接对每个点维护相邻的点的平衡树，修改就暴力修改，查询就直接查询就可以了。

~~显然不对~~

那么我们怎么优化这个算法呢？

我们可以先进行树链剖分，然后每个点只维护她的轻儿子的平衡树。

为什么要怎么做呢？它与暴力有什么区别呢？

考虑树剖的性质。我们每次修改时，最多经过$logn$条重链，每条链只有链头的父亲的一个轻儿子（即链头）发生了改变。我们暴力删除插入，复杂度是$log^2n$的。

我们每次询问，就暴力把那个点，她的父亲，她的重儿子插入在查询第$k$小就可以了。

~~然后，你告诉我你只有80分？~~

好吧，实话实说，这题卡平衡树。如果你用$Splay$或$FHQ\;Treap$是卡不过去的，不信你试试？~~试试就逝世~~，我们要用常数更优秀的平衡树。我这里选择了$WBLT$。然而你还是只有$80$分？，快读加火车头~~多交几遍暴力*过去~~就$ok$了。

另外有两个小细节

一定要看这个点到底有没有重儿子与父亲。
你在修改跳链，最后跳到一个链上时，一定要看一下是不是跳到了链头，如果是还要做一次额外修改。

最后，$WBLT$大法吼啊！$orz\;lxl$

$Code$

struct Node
{
 int val,siz;
 Node *lc,*rc;
 Node(int siz,int val,Node *lc,Node *rc) : siz(siz),val(val),lc(lc),rc(rc) {}
 Node() {}
};

struct edge
{
 int v,nxt;
}e[maxn<<1];
int head[maxn],kt,n,id[maxn];
int dfn[maxn],dep[maxn],son[maxn],siz[maxn],top[maxn],fa[maxn],cnt,a[maxn];

inline int max(const int &x,const int &y) {return x>y?x:y;}
inline int min(const int &x,const int &y) {return x<y?x:y;}
inline void add(const int &u,const int &v) {e[++kt]=(edge){v,head[u]};head[u]=kt;}

struct Leafy_Tree
{
 Node *rt[maxn],*stk[maxn<<2],utk[maxn<<2],*null;
 int utot;
 const int ratio=3;
 #define newnode(a,b,c,d) (&(*stk[utot++]=Node(a,b,c,d)))
 #define merge(a,b) newnode(a->siz+b->siz,b->val,a,b)
 inline void init(int n)
 {
 null=new Node(0,0,0,0);
 for(int i=0;i<n*3;++i)
 stk[i]=&utk[i];
 for(int i=0;i<=n+1;++i)
 rt[i]=newnode(1,2147483647,null,null);
 }
 inline void rotate(Node *u)
 {
 if(u->lc->siz > u->rc->siz*ratio)
 u->rc=merge(u->lc->rc,u->rc),stk[--utot]=u->lc,u->lc=u->lc->lc;
 else if(u->rc->siz > u->lc->siz*ratio)
 u->lc=merge(u->lc,u->rc->lc),stk[--utot]=u->rc,u->rc=u->rc->rc;
 }
 inline void pushup(Node *u)
 {
 if(!u->lc->siz) return;
 u->siz=u->lc->siz+u->rc->siz;
 u->val=u->rc->val;
 }
 inline void insert(Node *u,int val)
 {
 if(u->siz==1)
 {
 u->lc=newnode(1,min(val,u->val),null,null);
 u->rc=newnode(1,max(val,u->val),null,null);
 }
 else insert(val > u->lc->val ? u->rc : u->lc,val);
 pushup(u);rotate(u);
 }
 inline void erase(Node *u,int val)
 {
 if(u->lc->siz==1&&u->lc->val==val)
 stk[--utot]=u->lc,stk[--utot]=u->rc,*u=*u->rc;
 else if(u->rc->siz==1&&u->rc->val==val)
 stk[--utot]=u->lc,stk[--utot]=u->rc,*u=*u->lc;
 else erase(val > u->lc->val ? u->rc : u->lc,val);
 pushup(u);rotate(u);
 }
 inline int kth(Node *u,int k)
 {
 if(u->siz==1) return u->val;
 return k > u->lc->siz ? kth(u->rc,k-u->lc->siz) : kth(u->lc,k);
 }
}leafy;

struct BIT
{
 int sum[maxn];
 #define lowbit(x) (x&(-x))
 inline void modify(int x,int val) {while(x<=n+5) sum[x]+=val,x+=lowbit(x);}
 inline int query(int x) {int res=0;while(x) res+=sum[x],x-=lowbit(x);return res;}
}bit;

void dfs1(int u,int f)
{
 fa[u]=f;dep[u]=dep[f]+1;siz[u]=1;
 for(int i=head[u];i;i=e[i].nxt)
 if(e[i].v!=f)
 {
 dfs1(e[i].v,u);siz[u]+=siz[e[i].v];
 if(siz[e[i].v]>siz[son[u]]) son[u]=e[i].v;
 }
}

void dfs2(int u,int topf)
{
 top[u]=topf;dfn[u]=++cnt;id[cnt]=u;
 if(!son[u]) return;
 dfs2(son[u],topf);
 for(int i=head[u];i;i=e[i].nxt)
 if(e[i].v!=fa[u]&&e[i].v!=son[u])
 dfs2(e[i].v,e[i].v),leafy.insert(leafy.rt[u],a[e[i].v]);
}

inline void modify(int u,int v,int val)
{
 while(top[u]^top[v])
 {
 if(dep[top[u]]<dep[top[v]]) u^=v^=u^=v;
 if(fa[top[u]]) leafy.erase(leafy.rt[fa[top[u]]],bit.query(dfn[top[u]]));
 bit.modify(dfn[top[u]],val),bit.modify(dfn[u]+1,-val);
 if(fa[top[u]]) leafy.insert(leafy.rt[fa[top[u]]],bit.query(dfn[top[u]]));
 u=fa[top[u]];
 }
 if(dep[u]>dep[v]) u^=v^=u^=v;
 if(u==top[u]&&fa[u]) leafy.erase(leafy.rt[fa[u]],bit.query(dfn[u]));
 bit.modify(dfn[u],val);bit.modify(dfn[v]+1,-val);
 if(u==top[u]&&fa[u]) leafy.insert(leafy.rt[fa[u]],bit.query(dfn[u]));
}

inline int query(int u,int k)
{
 int valu=bit.query(dfn[u]),valf,vals,ans;
 leafy.insert(leafy.rt[u],valu);
 if(fa[u]) valf=bit.query(dfn[fa[u]]),leafy.insert(leafy.rt[u],valf);
 if(son[u]) vals=bit.query(dfn[son[u]]),leafy.insert(leafy.rt[u],vals);
 ans=leafy.kth(leafy.rt[u],k);
 leafy.erase(leafy.rt[u],valu);
 if(fa[u]) leafy.erase(leafy.rt[u],valf);
 if(son[u]) leafy.erase(leafy.rt[u],vals);
 return ans;
}

int main()
{
 int opt,x,y,z,t;
 read(n);read(t);
 for(int i=1;i<=n;++i)
 read(a[i]);
 for(int i=1;i<n;++i)
 {
 read(x);read(y);
 add(x,y);add(y,x);
 }
 leafy.init(n);
 dfs1(1,0);dfs2(1,1);
 for(int i=1;i<=n;++i)
 bit.modify(i,a[id[i]]),bit.modify(i+1,-a[id[i]]);
 while(t--)
 {
 read(opt);read(x);read(y);
 if(opt==1) read(z),modify(x,y,z);
 else write(query(x,y),'\n');
 }
 flush();
 return 0;
}

题解 P6812 【「MCOI-02」Ancestor 先辈】

Wed, 01 Jan 2020 00:00:00 +0000

线段树入门题。

题意很清晰，通过观察屑的定义，可以发现先辈有如下性质：

对于长度为$n$序列$a$，如果它是先辈，那么它满足：

$a_1\le a_2\le a_3 \cdots\le a_n$

为什么呢？通过观察，我们发现先辈的后缀中除了它自己外，它的最长后缀的需要满足的关系最强（即如上性质），而其他后缀需要满足的关系是它的子集，比如第二长的后缀需要满足的关系是$a_1\le a_3, a_2\le a_4 \cdots$，显然更弱，所以说问题转化成了：

区间加
询问一个区间是否单调上升

然后变成了线段树裸题。

具体做法：线段树维护区间左端点的值$lv$，区间右端点的值$rv$，区间是否是先辈。$pushup$时，如果一段区间的左右儿子都是先辈，并且左儿子的$rv$小于等于右儿子的$lv$，则这段区间是先辈，询问同理。

不要试图抄我的代码，直接交会$wa$一个点

代码（很短的）：

inline void update(int u,ll k)
{
 tr[u].lv+=k;tr[u].rv+=k;tr[u].la+=k;
}

inline void pushup(Node &u,const Node &a,const Node &b)
{
 u.lv=a.lv;u.rv=b.rv;
 u.is=a.is&&b.is&&(a.rv<b.lv);
}

inline void pushdown(int u)
{
 if(!tr[u].la) return;
 update(u<<1,tr[u].la);update(u<<1|1,tr[u].la);
 tr[u].la=0;
}

void build(int u,int l,int r)
{
 if(l==r) {tr[u].lv=tr[u].rv=a[l];tr[u].is=1;return;}
 int mid=(l+r)>>1;
 build(u<<1,l,mid);build(u<<1|1,mid+1,r);
 pushup(tr[u],tr[u<<1],tr[u<<1|1]);
}

void modify(int u,int l,int r,int x,int y,ll val)
{
 if(x<=l&&r<=y) return update(u,val);
 int mid=(l+r)>>1;
 pushdown(u);
 if(x<=mid) modify(u<<1,l,mid,x,y,val);
 if(y>mid) modify(u<<1|1,mid+1,r,x,y,val);
 pushup(tr[u],tr[u<<1],tr[u<<1|1]);
}

Node query(int u,int l,int r,int x,int y)
{
 if(x<=l&&r<=y) return tr[u];
 int mid=(l+r)>>1;
 pushdown(u);
 if(y<=mid) return query(u<<1,l,mid,x,y);
 if(x>mid) return query(u<<1|1,mid+1,r,x,y);
 Node ans;pushup(ans,query(u<<1,l,mid,x,y),query(u<<1|1,mid+1,r,x,y));
 return ans;
}

template<typename T>
inline void read(T &x)
{
 char c;int f=1;
 while(!isdigit(c=getchar())) (c=='-')&&(f=-1);
 x=c^48;
 while(isdigit(c=getchar())) x=x*10+(c^48);
 x*=f;
}

int main()
{
 int t,opt,x,y;
 ll val;
 read(n);read(t);
 for(int i=1;i<=n;++i) read(a[i]);
 build(1,1,n);
 while(t--)
 {
 read(opt);read(x);read(y);
 if(opt==1) read(val),modify(1,1,n,x,y,val);
 else printf("%s\n",query(1,1,n,x,y).is?"Yes":"No");
 }
 return 0;
}

题解 P7096 【[yLOI2020] 泸沽寻梦】

Wed, 01 Jan 2020 00:00:00 +0000

场外选手来水波题解。

Part.1

先考虑询问怎么做。

首先我们考虑异或有一个很好的性质，可差分性。

考虑对序列做一个前缀异或和，一段区间$[l,r]$的异或和为$0$,实际上就是$sum[r]\oplus sum[l-1]=0$。所以现在我们只用查询序列中有几个相等的数对，这个就可以随便做了。

Part.2

考虑修改操作很有特点，每次修改的数都是相邻的两个数，对前缀和的影响是$sum[p]$变为了$sum[p]\oplus x$，$sum[p+1...n]$变为了$sum[p+1...n]\oplus x\oplus x=sum[p+1...n]$，实际上发生改变的前缀就只有$sum[p]$！

所以问题就变得很简单了，我们只需要先扫一遍统计一下开始的答案，每次先删除原来$sum[p]$的贡献，再加入修改后的$sum[p]$就可以了。

随便拿个值域数据结构做就是了，我写了个$01\text{trie}$，当然拿动态开点值域线段树或平衡树，$\text{map}$之类的都可以啦。

答案记得开$\text{long long}$。

代码：

#include <cstdio>
#include <iostream>
using namespace std;
typedef long long ll;
const int maxn=1e6+5,lim=29;

int tr[maxn*lim][2],siz[maxn*lim],sum[maxn],cnt=1,n,m,cntx;
ll totans,mx,mi;

template<typename T>
inline void read(T &x)
{
 int f=1;char c;
 while(!isdigit(c=getchar())) if(c=='-') f=-1;
 x=c^48;
 while(isdigit(c=getchar())) x=x*10+(c^48);
 x*=f;
}

void insert(int x,int f=1)
{
 int u=1;
 for(int i=lim;~i;--i)
 {
 int c=x>>i&1;
 if(!tr[u][c]) tr[u][c]=++cnt;
 u=tr[u][c];siz[u]+=f;
 }
}

int query(int x)
{
 int u=1;
 for(int i=lim;~i;--i)
 {
 int c=x>>i&1;
 u=tr[u][c];
 if(!u) return 0;
 }
 return siz[u];
}

int main()
{
 int p,x;
 ll ans=0;
 read(n);read(m);
 for(int i=1;i<=n;++i)
 read(sum[i]),sum[i]^=sum[i-1];
 for(int i=0;i<=n;++i)
 ans+=query(sum[i]),insert(sum[i]);
 mx=0;mi=1e18;
 while(m--)
 {
 read(p);read(x);
 insert(sum[p],-1);
 ans-=query(sum[p]);
 sum[p]^=x;
 ans+=query(sum[p]);
 insert(sum[p]);
 totans^=ans;cntx+=(ans&1);
 mx=max(mx,ans);mi=min(mi,ans);
 }
 printf("%lld\n%d\n%lld\n%lld\n",totans,cntx,mx,mi);
 return 0,QAQ;
}