【JOISC 2020 补题记录】
花点时间把 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
还不会，听说是大数据结构题。
考虑子任务 \(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
听说是最短路。仔细一想挺有道理。那么下次一定补。
