【JOISC 2020 补题记录】

Day 1
Day 2
Day 3
Day 4

花点时间把 JOISC2020 给补了吧。

好好认识一下当时考场上的自己是多么智障。

目前进度：6.9/12。

Day 1

Building 4

考虑相邻两个 $(A_i, B_i)$ 与 $(A_{i+1},B_{i+1})$（不妨假设 $A_i\leq B_i,A_{i+1}\leq B_{i+1}$，其他情况同理），根据它们的大小关系分几类：

（1）$B_i > B_{i+1}$，这时无法选择 $B_i$，强制选择 $A_i$。

（2）$A_i > A_{i+1}$，这时无法选择 $A_{i+1}$，强制选择 $B_{i+1}$。

（3）$B_i\leq A_{i+1}$，这时 $i$ 的决策与 $i + 1$ 无关。

（4）否则，如果选择了 $A_{i+1}$ 则强制选 $A_i$；如果选择 $B_{i+1}$ 则 $i$ 随便选。

那么原序列可被划分成若干个段，每个段以情况（3）结尾（即段与段之间不影响）。

且每个段内部一定是前半部分选 $\min\{A_i,B_i\}$，后半部分选 $\max\{A_i,B_i\}$（在满足情况（1）、（2）的限制的前提下）。

那么就可以得到每个段最少取多少个 $A_i$，最多取多少个 $A_i$。判是否可以凑出 $N$ 个 $A_i$ 以及构造方案也就迎刃而解了。

起码能够切一道题，挺好的。

提交记录链接（写得有些冗长）。

Hamburg Steak

题目链接。

还不会，听说是随机化。

Sweeping

题目链接。

还不会，听说是大数据结构题。

先放个又臭又长的6K代码（逃。

考虑子任务 $3$，发现每次操作是对一段连续的灰尘操作，平衡树区间 tag 即可。

考虑子任务 $4$，已经扫过的灰尘必然满足子任务 $3$ 的限制，只需要求出每个灰尘什么时候被第一次扫到即可。分析发现其实是一维问题，线段树即可（不过貌似写线段树是增加码量的无脑行为）。

考虑子任务 $5$，将 “灰尘加入的时间 $\to$ 询问时间” 这段拆解到线段树，做个线段树分治。这样可以做到 $O(Q\log^2Q)$。

草它怎么还可以没有扫地操作啊。

Day 2

Chameleon’s Love

题目链接。

不会做的交互题，咕了。

Making Friends on Joitter is Fun

题目链接。

如果存在边 $(x, y), (y, x)$，我们就称 $x, y$ 是等价类。

可以发现等价关系具有传递性，且满足两个等价结点的入边集合相同（但出边集合不一定相同）

合并等价类时采用启发式合并，维护结点->连通块的入边集合与出边集合（方便维护答案），再维护连通块->连通块的入边集合与出边集合（方便后续的连锁合并）即可。

时间复杂度 $O(n\log^2n)$。

明明是一道裸的启发式合并，为什么我当时没做不出来，为什么我补题的时候还WA了若干次才过。

提交记录链接。

Ruins 3

题目链接。

不会做的计数题，咕了。

Day 3

Constellation 3

题目链接。

最大权独立集是np问题，下一个。

倒过来对黑色部分建笛卡尔树，树上每个结点 i 管辖区间为 [li, ri]，区间内最小高度为 hi。

我们称一个星星 (x, y) 属于结点 i，当且仅当 li <= x <= ri 且 y <= hi。

可以发现一个星星对应的结点在树上呈一条竖直的链。

定义 dp(i) 表示在 i 的子树里面选星星（星星对应的链不能超过 i）的最大独立权值和。

转移时如果选中星星 p，相当于去掉 p 对应的链，剩下的若干子树的 dp 之和。

这是个经典题目，可以通过打 tag + 启发式合并做到 $O(n\log^2n)$。

也可以维护可并堆，以链的最高顶点的深度为权值，每次弹出链最高顶点的深度 = 当前结点深度的点，并更新 dp 值。这样就是 $O(n\log n)$ 的。

最后用总和 - 最大独立和 = 最小不自然度。

提交记录链接。

Harvest

题目链接。

基环树分类大讨论，写不来，下一个。

Stray Cat

题目链接。

通信题，最后 9 分不会拿，下一个。

（1）$A>2$：

建出最短路图，边 $(u, v)$ 的颜色记为 $\min\{dis_u, dis_v\}\mod 3$。

点 $x$ 连接的边有三类：同层（颜色为 $dis_x \mod 3$）；上一层（颜色为 $dis_x-1\mod 3$，且必定存在）；下一层（颜色为 $dis_x\mod 3$）。

找出 $\mod 3$ 意义下不存在的颜色，就可以每次顺着最短路往上爬。

（2）$A=2$：

非二度点可以将父边设为一种颜色，子边设为另一种颜色。根据颜色数量即可判断方向。

二度点如果已经确定上一次走过的边是往根爬，则沿着另一条边继续往根爬。

现在考虑一条由二度点构成的链，如何走有限步判断根的方向。

如果链的循环节 S 与它的翻转串 S' 循环同构，则显然无法区分方向。

注意到 |循环节| < 6 时不存在合法循环节；|循环节| = 6 时有合法循环节 $010011$。

于是我们可以走 6 步确认出循环节判断方向，如果方向不对再往回跑。但是这样最劣需要多走 12 步，只能得到 91 分。

注意到我们只需要 4 步就可以确定长度为 6 的循环节（利用起终点的相邻颜色信息），这样最劣 8 步。

进一步，我们不需要确认整个循环节，只需要取长度为 5 的子串即可。这样最劣 6 步，足以通过本题。

提交记录链接。

Day 4

Capital City

题目链接。

暴力显然直接跑 tarjan。考虑优化建图。

虚树 + 树上路径连边（用类 st 表的思想可以只连 $O(1)$ 条边）。

提交记录链接（loj排行榜上几乎垫底的代码）。

Legendary Dango Maker

题目链接。

提答是不可能补的，这辈子都不可能补的。

结果还是为了 noi 可能出现的题答来补题了。

发现这本质是最大独立集，于是直接跑随机化算法。

大致思路就是随机一个白格，如果它可以新串一个就贪心地串，否则尝试更换其他匹配（不过不能让匹配个数变少）；如果它本身有匹配，则尝试旋转这个匹配。

可以模拟退火一下（即一开始更换匹配的概率很低，后面越来越高）。

将代码（目前跑到了 99 分）附在这里。仅供参考。

#include <bits/stdc++.h>

using namespace std;

const int N = 500;

const int dx[] = {0, 1, 1, 1};

const int dy[] = {1, 0, 1, -1};

mt19937 gen((time(NULL)) ^ clock());

struct point{

	int x, y;

	friend bool operator == (const point &a, const point &b) {

		return a.x == b.x && a.y == b.y;

	}

};

char s[N + 5][N + 5]; int n, m;

bool check(point p, int o) {

	if( s[p.x][p.y] != 'W' ) return false;

	point q1 = (point){p.x + dx[o], p.y + dy[o]};

	point q2 = (point){p.x - dx[o], p.y - dy[o]};

	if( q2.x < 1 || q2.y < 1 || q1.x < 1 || q1.y < 1 ||

		q2.x > n || q2.y > m || q1.x > n || q1.y > m ) return false;

	if( s[q1.x][q1.y] == 'W' || s[q2.x][q2.y] == 'W' ) return false;

	return s[q1.x][q1.y] != s[q2.x][q2.y];

}

point lnk[N + 5][N + 5]; int a[N + 5][N + 5], ans;

bool try_add(point p, int o) {

	point q1 = (point){p.x + dx[o], p.y + dy[o]};

	point q2 = (point){p.x - dx[o], p.y - dy[o]};

	if( lnk[q1.x][q1.y].x == 0 && lnk[q2.x][q2.y].x == 0 ) {

		a[p.x][p.y] = o, lnk[q1.x][q1.y] = lnk[q2.x][q2.y] = p, ans++;

		return true;

	} else return false;

}

bool try_replace(point p, int o) {

	point q1 = (point){p.x + dx[o], p.y + dy[o]};

	point q2 = (point){p.x - dx[o], p.y - dy[o]};

	if( lnk[q1.x][q1.y].x && lnk[q2.x][q2.y].x ) return false;

	if( a[p.x][p.y] != -1 && (lnk[q1.x][q1.y].x || lnk[q2.x][q2.y].x) ) return false;

	if( a[p.x][p.y] != -1 ) {

		point q3 = (point){p.x + dx[a[p.x][p.y]], p.y + dy[a[p.x][p.y]]};

		point q4 = (point){p.x - dx[a[p.x][p.y]], p.y - dy[a[p.x][p.y]]};

		lnk[q3.x][q3.y] = lnk[q4.x][q4.y] = (point){0, 0};

	} else {

		if( lnk[q2.x][q2.y].x ) swap(q1, q2);

		point p2 = lnk[q1.x][q1.y], q3 = (point){2*p2.x - q1.x, 2*p2.y - q1.y};

		lnk[q1.x][q1.y] = lnk[q3.x][q3.y] = (point){0, 0}, a[p2.x][p2.y] = -1;

	}

	lnk[q1.x][q1.y] = lnk[q2.x][q2.y] = p, a[p.x][p.y] = o;

	return true;

}

vector<point>w;

vector<int>dir[N*N + 5];

int main() {

	srand(gen());

	scanf("%d%d", &n, &m);

	for(int i=1;i<=n;i++)

		scanf("%s", s[i] + 1);

	for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) for(int o=0;o<4;o++)

		if( check((point){i, j}, o) ) {w.push_back((point){i, j}); break;}

	for(unsigned i=0;i<w.size();i++) for(int o=0;o<4;o++)

		if( check(w[i], o) ) dir[i].push_back(o);

	for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) a[i][j] = -1;

	for(int tme=1;tme<=10000;tme++) {

		random_shuffle(w.begin(), w.end());

		for(unsigned i=0;i<w.size();i++) {

			random_shuffle(dir[i].begin(), dir[i].end());

			for(unsigned o=0;o<dir[i].size();o++) {

				if( gen() % (tme + 1) <= tme && check(w[i], dir[i][o]) ) {

					if( a[w[i].x][w[i].y] != -1 || !try_add(w[i], dir[i][o]) )

						if( a[w[i].x][w[i].y] != dir[i][o] && gen() % 3 <= 2 )

							if( try_replace(w[i], dir[i][o]) ) break;

				}

			}

		}

		cerr << tme << " " << ans << endl;

	}

	for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) {

		if( a[i][j] != -1 ) {

			assert(check((point){i, j}, a[i][j]));

			if( a[i][j] == 0 ) putchar('-');

			else if( a[i][j] == 1 ) putchar('|');

			else if( a[i][j] == 2 ) putchar('\\');

			else if( a[i][j] == 3 ) putchar('/');

		} else putchar(s[i][j]);

		if( j == m ) puts("");

	}

}

Treatment Project

题目链接。

听说是最短路。仔细一想挺有道理。那么下次一定补。