PandaGhost’s Blog

【也许你不想学】无公式复原魔方：降群法

2023-12-25T00:00:00+00:00

从小到大我们接触魔方都是从公式开始的。我们学会了魔方，却只是依靠公式的力量。要真正了解魔方，就必须抛开公式。降群法（Thistlethwaite Method）可以让你从本质上学会魔方。

群

群是一个很好理解的数学概念，可以类比生活中的一个小团体。

集合 $G$ 和在集合 $G$ 上的二元运算 $\cdot$ 构成了代数结构 $(G, \cdot)$ 满足封闭性、结合律、单位元、逆元的性质称之为群。

封闭性： $\forall x \forall y, (x, y \in G) \to (x \cdot y \in G)$

结合律： $\forall x \forall y \forall z, (x, y, z \in G) \to ((x \cdot y) \cdot z = x \cdot (y \cdot z))$

单位元： $\exists e, (e \in G) \wedge (\forall x, (x \in G) \to (e \cdot x = x \cdot e = x))$

逆元： $\forall x, (x \in G) \to (\exists y, (y \in G) \wedge (x \cdot y = y \cdot x = e))$

例如，整数对加法是一个群、任何一个有限集的所有置换对复合运算构成对称群。

群的概念很好理解，这里做初步了解即可。

降群法初探

降群法（Thistlethwaite Method）简称 TM，最初是用于计算机解决魔方问题的。

它不像诸如 CFOP 和桥式一样优先复原几块或几层，这样会导致后面的步骤要求不打乱原来的部分，因而就有了公式的必要性。

它的总体上的思路是从整体上慢慢的恢复的有规律，看似没有一个面是复原的，而最后只需数步即可复原。

而使其变得有规律的方式是将魔方的状态看作群，将其慢慢的简化，直至简化成最初的状态。

我们来了解一下魔方的群。

辛马斯特标记

用 Up, Down, Left, Right, Front, Back 的首字母表示表示上下左右前后六个面。

单独一个字母表示顺时针 $90 ^{\circ}$，加 ‘ 表示逆时针 $90 ^{\circ}$，加 2 表示转 $180 ^{\circ}$。

例如，U’

魔方群

魔方的一次操作可以看做对于魔方的 $6\times 9=54$ 个面的置换。这样一来，我们把魔方每一个状态，看作从初始状态到这的置换。我们研究的对象从转为置换。这些置换对复合运算构成一个群。

封闭律，显然你无论怎么转都不会出这个集合。结合率，也显然。单位元，就是什么都不转，计作 $\text{I}$。逆元，就是倒着做。

对于魔方群 $(G, \cdot)$ 的描述

使用 $\cdot$ 表示复合运算。我们称 $S$ 为集合 $G$ 的基本元素意思是：

$\forall x \in S, x\in G$
$\forall x, y \in G, x\cdot y \in G$

以这种方式由 $S$ 构造 $G$。

用人话说，就是只使用基本元素不断组合，能转动到的状态的集合，很好理解吧。

降群法里的群

	基本元素	大小
$G0$	${\text{I, U, D, L, R, F, B}}$	$4.33 \times 10^{19}$
$G1$	${\text{I, U, D, L, R, F2, B2}}$	$2.11 \times 10^{16}$
$G2$	${\text{I, U, D, L2, R2, F2, B2}}$	$1.95 \times 10^{10}$
$G3$	${\text{I, U2, D2, L2, R2, F2, B2}}$	$6.63 \times 10^5$
$G4$	${\text{I}}$	$1$

各群的等价特征

这是你在实际过程中复原的最重要的部分。我们不妨以黄面为顶，红面朝前。

G1

G1 等价于棱块色相正确。什么是棱块色相正确呢？

因为黄白色对面，红橙色对面，蓝绿色对面。我们称上下两面的颜色为高级色，前后两面的颜色为中级色，左右两面的颜色为低级色。又称高级色比中级色高级，中级色比低级色高级，高级色比低级色高级。

我们称面 UR 指的是 U 面于 R 面交界的棱块上的处于 U 面的面，面 RU 指的是 U 面于 R 面交界的棱块上的处于 R 面的面。

面 UR:

面 RU:

则棱块色相正确是指 UL,UR,UF,UB,DL,DR,DF,DB,FL,FR,BL,BR 这 12 个面比对应棱块的另一个面颜色高级

显然棱块色向正确是处于 G1 群的必要条件，因为对于初始状态，棱块色相正确。而通过 U,D,L,R,F2,B2 不会改变色相。至于充分性，留给读者作为课后思考题。

G2

G2 等价于在 G1 的基础上要求上下面只有黄白色。此时由于棱块色向已经正确，可知中层的颜色只会存在对色。

显然其必要性也是很好理解的，因为 L,R,F,B 都只能转动 $180 ^{\circ}$，所以上下只有黄白色。

G3

G3 等价于每一个面只存在原色和对色且角块相对位置正确。

角块相对位置正确保证角块可以恢复。

对于棱块，在角块复原的时候可以证明棱块只存在对色和原色与 G3 等价。对于必要性显然。至于充分性，首先可知棱块在每个中层四个棱块是一个置换。然后证明只用 U2,D2,L2,R2,F2,B2 可以实现 (1)一个中层内的三棱换 (2)两个中层各交换两个棱块。如果证明了 (1) (2) 就证明了等价性，因为不可能只存在两个棱块需要交换。

(1)

F2 R2 F2 R2 F2 R2 U2 L2 F2 U2 B2 R2 D2 B2 U2 B2 L2 U2 R2 F2 D2 R2

(2)

有三种情况

F2 R2 F2 R2 F2 R2

U2 R2 U2 R2 U2 R2 F2 L2 D2 F2 U2 R2 F2 D2 F2 B2

iii

U2 L2 U2 L2 U2 L2 转化为 (1)

复原方法

其实在掌握了以上的性质后，这一部分可以自己摸索。

G0->G1

因为 G1 等价于棱块色相正确。注意到只有 F 和 B 会改变 4 棱块的个色相。所以可以将 4 个错误的棱块放到 F 面一起解决。如果只有 2 个棱块色相不对，则将 1 个色相不对的放在 F 面，转动 F，则产生 3 个错误的色相块，与原来 1 个凑成 4 个一起解决。

G1->G2

要求上下面只有黄白色，可以先恢复角块，后处理棱块。

G2->G3

首先解决角块的相对位置。然后处理棱块。

G3->G4

~~乱拧一通~~，其实这里只转 $180 ^{\circ}$ 恢复是有点困难的，可以适当使用一些非法的步骤，后面记得还原。如 U2 M U2 M’。

思考

降群法最初是使用到计算机上的，现在计算机解决魔方使用的是两阶段法，也是基于降群法的。在最少步的人类方法中有一种叫 DR（多米诺降群法）的方法。

魔方本来是作为一个娱乐的玩意儿，但是小小的它中又有奇特的奥秘，待我们研究。这就是它的魅力。

余杭区和临平区

2023-12-10T00:00:00+00:00

地理位置

余杭区，隶属于浙江省杭州市，地处于杭州市西、北部，东临京杭大运河，西倚天目山，南濒钱塘江，中贯东苕溪，东与拱墅区、西湖区接壤，东北与临平区相连，西与临安区为邻，西南与富阳区相接，北与德清县毗连，西北与安吉县相交，总面积940平方千米。

临平区，浙江省杭州市下辖区，位于长三角都市群南翼、杭州市东北部，北接湖州市德清县、南濒钱塘江、西至京杭运河、东依嘉兴市海宁市，区域面积286平方千米。

历史（主要是余杭区）

马家浜文化时期

从余杭境内吴家埠、荀山、小古城等遗迹的发掘表明，早在7000年-6000年以前的马家浜文化时期，已有先民在此生息繁衍。
良渚文化

余杭区的良渚遗址，年代约为距今5300-4300年。
春秋战国

余杭之名，春秋时已见诸史籍，彼时先属越，后属吴，后复属越，战国中期属楚。
秦

秦王政二十五年（公元前222年），秦灭楚，境内置钱唐（含杭州城区）、余杭两县，属会稽郡（钱唐几经变更，到民国为杭县，余杭区系由原余杭县和杭县大部地域合并而成）
汉

西汉时，余杭、钱唐两县仍属会稽郡，钱唐为会稽郡西部都尉治。平帝元始四年（4年），改钱唐县为泉亭县。新王莽始建国元年（9年），改余杭县为进睦县。东汉建武元年（25年），复名余杭、钱唐
三国孙吴

三国时，余杭、钱唐均入孙吴版图，属吴郡，隶扬州，钱唐县并为吴郡都尉治。
隋

隋开皇九年（589年），废钱唐郡，改置杭州，州治初设余杭，次年移钱唐。大业三年（607年），又改杭州为余杭郡，钱唐、余杭仍为所属。
唐

唐武德四年（621年）复余杭郡为杭州，为避国号讳，改钱唐为钱塘。
五代十国

五代后梁龙德二年（922年），划钱塘、盐官两县地各半及富春县之两乡地置钱江县，与钱塘县同城设治。
宋

北宋太平兴国四年（979年），改钱江县为仁和县。南宋建炎三年（1129年），升杭州为临安府，属两浙西路。钱塘、仁和升赤，余杭升畿。

北宋端拱元年（988年），临平建镇。
元明清

元至元十五年（1278年），改临安府为杭州路，钱塘、仁和、余杭属之。至正二十六年（1366年），朱元璋攻下杭州，改杭州路为杭州府。明清延之。
中华民国

民国元年（1912年）2月，废杭州府，以原钱塘、仁和县地并置杭县，与余杭县同属钱塘道。民国16年废道制，实行省、县二级制，划杭县城区、西湖、会堡、江干、皋塘、湖墅等地，建立杭州市。民国24年，设行政督察区。余杭属第一行政督察区，杭县属第二行政督察区。民国29年，调整行政督察区，杭县、余杭均属第一行政督察区。民国36年，杭县改为省直属县；余杭仍属第一行政督察区，7月，改属第九行政督察区。
建国以来

1949年5月，两县解放，余杭、杭县建制未变。

1958年4月，杭县被撤销，属杭州市郊区。余杭县亦于1958年10月撤销，并入临安县。

1960年1月，建立钱塘联社（县级）。

1961年3月，从临安县析出原余杭县境与钱塘联社合并，4月，钱塘联社撤销，恢复县建制，定名余杭县，县治设临平镇。

1994年4月，撤销余杭县，设立县级余杭市。

2001年2月2日，撤销县级余杭市，设立杭州市余杭区。

2021年3月11日，浙江省人民政府发布《关于调整杭州市部分行政区划的通知》。撤销杭州市余杭区，设立新的杭州市余杭区。

2021年4月9日，浙江省人民政府发布《关于调整杭州市部分行政区划的通知》，设立杭州市临平区，临平区人民政府驻地临平街道西大街33号。

经济

GDP

经济综述

余杭区

历史上的余杭是著名的鱼米之乡、丝绸之府，以农业发达著称。改革开放以来，余杭区经济出现重大调整，工业经济已成为国民经济的主体、财政收入的主体、劳动就业的主体。近年来，余杭区依托杭州未来科技城、余杭经济技术开发区、临平新城、良渚新城、钱江经济开发区（仁和基地）等重点产业平台，打造梦想小镇、梦栖小镇、艺尚小镇、人工智能小镇等一大批特色小镇，经济水平迅猛发展。

未来科技城

知名企业 阿里巴巴、字节跳动、菜鸟网络、OPPO、VIVO、同花顺、抖音

高等学府 杭州师范大学、中国美术学院良渚校区、中法航空大学

产业电子信息产业、生物医药研发、新能源新材料研发、装备制造研发、软件等

发展定位 杭州城市“第三中心”

临平区

教育

就高中而言，原本的余杭区有一所余杭高级中学

然后分区以后，新余杭区就没有一所好的学校，余杭高级中学改名为临平中学~~（简称临终）~~

今年以后所有余杭的学生就不能考临平区的学校，所以会有很多的的学生来考西少

天元公学

交通

余杭穿境而过的两条高速铁路（杭宁高铁、湖杭高铁）及城市轨道交通杭州地铁2号线、杭州地铁3号线、杭州地铁5号线、杭州地铁10号线、杭州地铁16号线、杭州地铁19号线、一条铁路（宣杭铁路）、三条国道（G320、G329、G104）、五条高速公路（杭宁高速公路、杭长（宜）高速公路、杭徽高速公路、申嘉杭高速公路、杭州绕城高速公路、杭州第二绕城高速公路）、两条主要河流（东苕溪、京杭大运河）和四条省道（S101、S201、S304、S205）

临平区形成以“一弧三射”高速公路网为骨架（“一弧”是指杭州市绕城高速公路；“三射”是指沪杭高速公路、杭浦高速公路、申嘉湖杭高速公路），以G104、G320两条普通国道和S304、S101两条普通省道为主干，以县乡公路为补充的公路网络。沪杭高速铁路、沪杭铁路、宣杭铁路途经临平区，干线铁路网总里程达47千米，干线铁路网密度达16.4千米/百平方千米，设有临平南站。截至2021年12月，临平区有货运码头36个、客运码头1个，锚地9处、泊位103个、专用码头2个。杭州地铁3号线途经临平区，设黄鹤山站、星桥站等2座车站；杭州地铁9号线途经临平区，设乔司南站、乔司站、翁梅站、临平南高铁站、南苑站、临平站、邱山大街站、荷禹路站、五洲路站、龙安站等10座车站。

分区小趣事

“临平吸血”

老余杭变成了新余杭

风景名胜

良渚遗址

径山

西溪湿地

超山风景名胜区

塘栖古镇景区

杭州国家版本馆

地方特产

中泰竹笛

径山茶

塘栖枇杷

鸬鸟蜜梨

视频

NOIP 退役寄

2023-11-20T00:00:00+00:00

退役了捏

day 1

T1 一眼出，想到对每个字符串处理出了最大的排列和最小的排列，然后一个字符串是否合法就可以等价于它的最小的排列严格小于其他字符串的最大的排列的最小值，一看嘛，区间最小值嘛，就 ST 表，然后

string Min(int l, int r){
    int d=log2(r-l+1);
    return max(st[d][l], st[d][r-(1<<d)+1]);
}

Min 里面写 max，寄

T2 想了很久，用并查集调了很长的时间，因为一些原因对拍始终对不出来，而大样例挂掉了。

焦急的等待中……

终于在最后调出来了，最不放心的一题，竟然 A 了

T3 $O(n^2)$ 的 DP 当 $x_i$ 与 $y_j$ 满足关系时 $f_{i,j}=f_{i-1,j-1}\ \text{or}\ f_{i, j-1} \ \text{or}\ f_{i-1, j}$ 否则 $f_{i, j}=0$

结果我 $f_{1, 1}=1$ 而不是 $x_1 \ne y_1$，又寄

T4 $O(nk)$ 暴力，没什么悬念

大概率 1= 没了

小图灵 20+100+35+36=191

洛谷 70+100+30+36=236

云斗 60+100+35+36=231

反正是最后一年了，再也回不去从前了

AFO

PS. 实际 50+100+30+36=216

CSP-S 2023复赛游记

2023-10-28T00:00:00+00:00

CSP-S 2023复赛游记

距离CSP-S还剩2天

早上打了套题，T3 使用 int 的返回值返回了 LLONG_MAX，爆了挂了 100pts, 这为我的复赛埋下了伏笔

晚上口胡了一个类型 ud 可以将无符号整数类型扩大两倍，即类似 unsigned int -> unsigned long long 或 unsigned long long -> unsigned __int128 从而无痛高精度，由 @ShwStone 实现

距离CSP-S还剩1天

这天我没干什么，打了个 FHQ-Treap，挂了

距离CSP-S还剩0天

早上我又打了个 FHQ-Treap 过了文艺平衡树

中午早早的来到考场门口

下午考试，我碰到了初中同学

T1 看到数据范围 $n\le 8$ 直接思考暴力，仔细一想就很容易想到对于每个输入的密码最多产生81种可能，放到 map 里存下来即可，过了两个样例就跳了

T2 第一反应 $O(n^3)$ 的区间DP，第二反应是用 stack 模拟可以优化到 $O(n^2)$ ，仔细一想可以 hash 维护 stack 里的情况，写了一发单 hash 被大样例卡了，然后改成双 hash，过了所有的大样例

出去上了个厕所

回来的时候开了 T3，T3 大模拟写了很长的时间，我感觉到头昏目眩，有点重心不稳，最后还是过了大样例，感觉稳了

只剩半个小时，看了眼 T4 没什么思路写了个骗分

期望得分 100 + 100 + 100 + 0 = 300 pts

晚上看到小图灵上的 T1 A了

距离CSP-S还剩-1天

早上登了 Luogu 自测了自己的代码 100 + 100 + 100 + 0 = 300 pts 符合预期

看到大佬 @ShwStone AK 了

晚上回寝室知道自己小图灵上的分数是 100 + 90 + 65 + 0 = 255 pts 我一度以为是双哈希被卡了，因为自己用的是常见的模数

距离CSP-S还剩-2天

重新上 Luogu 发现 T2 更新了数据把我卡到了 60 pts，我调了参数也过不了，甚至使用了三哈希

结果终于发现一个中间变量没有开 long long（寄）

然后调 T3 的 RE 发现是数组开小了（复寄） qwq~55555~

自测分数

Luogu: 100 + 60 + 100 + 0 = 260 pts

云斗：100 + 85 + 80 + 5 = 270 pts

小图灵：100 + 90 + 65 + 0 = 255 pts

梦熊: 100 + 100 + 75 + 0 = 275 pts

最低: 100 + 60 + 65 + 0 = 225 pts

~~可以感受到我一开始是300pts结果挂到225pts的心情麻~~

考场见两次祖宗的我还有救吗

20230721 题组题解报告

2023-07-22T00:00:00+00:00

20230721 题组题解报告

前言

做了此题，~~受教练逼迫~~特来写一篇题解

Warning

为表诚意，一下题目的代码皆为完整的正确的代码，您可以拿走对拍，但请不要抄袭，如果您抄袭了，我也没有办法。

T1 游戏 (game)

~~我妹有找到链接~~

题意简述

Alice 每次有 $\frac{1}{2^p}$ 的概率 $+2^{p-1}$（$p$ 可任取），Bob 每次有 $\frac12$ 的概率 $+1$

Alice 先手，初值均为 $0$ ，先 $\ge n \space (1\le n \le 500)$ 者获胜，求 Alice 最优策略下获胜的概率

分析

概率 DP，反正我考场上没有想出来。

以 $f_{i,j}$ 表示 Alice 先手时，Alice 剩 $i$ 分，Bob 剩 $j$ 分，Alice 先手时获胜的概率。

状态转移方程

设上一轮 Alice $p$ 取值是 $k$

Alice 成功 Bob 成功 $\frac{1}{2^k} \times \frac12 \times f_{i-2^{k-1},j-1}$
Alice 成功 Bob 失败 $\frac{1}{2^k} \times \frac12 \times f_{i-2^{k-1}, j}$
Alice 失败 Bob 成功 $(1-\frac1{2^k})\times \frac12 \times f_{i, j-1}$
Alice 失败 Bob 失败 $(1-\frac1{2^k})\times \frac12 \times f_{i, j}$

所以，对于 Alice 取 $k$ 的情况

\[\begin{gather} f_{i, j}=\frac1{2^{k+1}}(f_{i-2^{k-1},j-1}+f_{i-2^{k-1},j}) +(1-\frac1{2^k})\frac12 f_{i, j-1} + (1-\frac1{2^k})\frac12f_{i, j} \\ \Leftrightarrow f_{i, j}=\frac{ \frac1{2^k} (f_{i-2^{k-1}, j-1}+f_{i-2^{k-1}, j})+(1-\frac1{2^k})f_{i, j-1} } { 1+\frac1{2^k} } \end{gather}\]

对于所有情况

\[f_{i, j}=\min_{k \in N_+} \{ \frac{ \frac1{2^k} (f_{i-2^{k-1}, j-1}+f_{i-2^{k-1}, j})+(1-\frac1{2^k})f_{i, j-1} } { 1+\frac1{2^k} } \}\]

边界条件

\[\begin{gather}f_{a, i} =1 \space (i \in [0, n], a \le 0)\\ f_{i, a} =0 \space (i \in [1, n], a \le 0) \end{gather}\]

注意 $k$ 的范围好像要枚举到 $\log_2(4n)$

$O(n^2\log n)$

代码

#include 
using namespace std;
typedef long long ll;
#define FILE(x) freopen(#x".in", "r", stdin);\
                freopen(#x".out", "w", stdout)
#define REP(i, a, b) for(int i=(a); i<=(b); ++i)
#define REPd(i, a, b) for(int i=(a); i>=(b); --i)
inline ll rd(){
    ll r=0, k=1; char c; while(!isdigit(c=getchar())) if(c=='-') k=-k;
    while(isdigit(c)) r=r*10+c-'0', c=getchar(); return r*k;
}
const int N=550;
long double f[N][N], ans; // long double 更精确
int n;
int main(){
    FILE(game);
    n=rd(), f[0][0]=1;
    REP(i, 1, n) f[0][i]=1, f[i][0]=0;
    REP(i, 1, n) REP(j, 1, n){
        REP(k, 1, 15){
            int tmp=i-(1<<(k-1));
            if(tmp<0) tmp=0; // 注意判负
            long double t1=f[tmp][j],
            t2=f[tmp][j-1],
            t3=f[i][j-1];
            f[i][j]=max(f[i][j], ((1.0/(1<<k))*(t1+t2)+(1-(1.0)/(1<<k))*t3)/(1+1.0/(1<<k)));
        }
    }
    printf("%.6f", (double)f[n][n]);
    return 0;
}

T2 秘密文件 (cipher)

P2400 秘密文件 - 洛谷计算机科学教育新生态 (luogu.com.cn)

题意简述

将字符串进行压缩到最短，如 AAAAAAAAAABABABCCD => 9(A)3(AB)CCD

分析

有点 DP 的感觉

$f_{i, j}$ 表示 $S[i, j]$ 这段压缩到最短的长度，$Ans_{i,j}$ 表示 $S[i, j]$ 这段压缩到最短的结果

\[f_{i, j}= \min_{i \le k \lt j} \{ f_{i, k} +f_{k+1, j}\}\]

或者自己段重复部分压缩

还是看代码吧

$O(玄学\times n^3)$

代码

#include 
using namespace std;
typedef long long ll;
#define FILE(x) freopen(#x".in", "r", stdin);\
                freopen(#x".out", "w", stdout)
#define REP(i, a, b) for(int i=(a); i<=(b); ++i)
#define REPd(i, a, b) for(int i=(a); i>=(b); --i)
inline ll rd(){
    ll r=0, k=1; char c; while(!isdigit(c=getchar())) if(c=='-') k=-k;
    while(isdigit(c)) r=r*10+c-'0', c=getchar(); return r*k;
}
char ch[110];
int f[110][110], len;
string ans[110][110];
int dfs(int l=1, int r=len){
    if(l==r) return ans[l][r]=ch[l], f[l][r]=1;
    if(f[l][r]!=0) return f[l][r];
    REP(k, l, r-1){ // 由 [l,k] [k+1,j] 更新
        dfs(l, k); dfs(k+1, r);
        if(f[l][r]==0||f[l][k]+f[k+1][r]<f[l][r]){
            f[l][r]=f[l][k]+f[k+1][r];
            ans[l][r]=ans[l][k]+ans[k+1][r];
        }
    }
    REP(i, 1, (r-l+1)/2){ // 自己有重复段, i为段长, b为段数
        if((r-l+1)%i) continue;
        int b=(r-l+1)/i;
        stringstream tmp;
        string tmp2;
        tmp<<b<<'(';
        REP(k, l, l+i-1){ // 暴力比较
            REP(j, 1, b-1){
                if(ch[k+j*i]!=ch[k+(j-1)*i]){
                    goto out;
                }
            }
        }
        dfs(l, l+i-1);
        tmp<<ans[l][l+i-1]<<')';
        tmp>>tmp2;
        if(f[l][r]==0||f[l][r]>tmp2.length()){
            f[l][r]=tmp2.length();
            ans[l][r]=tmp2;
        }
        out:;
    }
    return f[l][r];
}
int main(){
    FILE(cipher);
    scanf("%s", ch+1);
    ch[0]='!';
    len=strlen(ch)-1;
    dfs();
    puts(ans[1][len].c_str());
    return 0;
}

T3 牛的杂技 (Cow Acrobats)

3045 – Cow Acrobats (poj.org)

题意简述

序列 ${ a_i }$ 的每一项 $a_i$ 有两个属性 $a_i.w$ 和 $a_i.s$

求 ${a_i}$ 的一个排列使

\[\max_{1\le i\le n} \{ \sum_{j=1}^{i-1} a_j.w -a_i.s\}\]

最小，输出最小值即可

分析

贪心

这道题我是机缘巧合做出来的

考场上我是先假设最大值会在 $i=n$ 时取到推出要最大化 $a_n.w+a_n.s$

然后又发现如果最大值在 $i=k\space (ki, a_i.w+a_i.s

然后，我~~就没有理由的~~大胆假设最优情况是按照 $w+s$ 升序排序

嗯，就 A 了

严谨证明

假设相邻两项分别为 $a_i$ 和 $a_{i+1}$

若 $a_i$ 在 $a_{i+1}$ 前更优

则考虑交换两项前后

\[\begin{gather} \max(\sum_{j=1}^{i-1} a_j.w-a_i.s, \sum_{j=1}^{i} a_j.w-a_{i+1}.s) \\< \max(\sum_{j=1}^{i-1} a_j.w-a_{i+1}.s, \sum_{j=1}^{i-1} a_j.w+a_{i+1}.w-a_{i}.s) \\ \Leftrightarrow \max(-a_i.s, a_i.w-a_{i+1}.s) < \max(-a_{i+1}.s, a_{i+1}.w-a_i.s) \\ \Leftrightarrow \max(a_{i+1}.s, a_i.w+a_i.s) <\max(a_i.s, a_{i+1}.w+a_{i+1}.s)\space _{(1)} \\ a_i.s < a_i.w+a_i.s \le \max(a_{i+1}.s, a_i.w+a_i.s)\space _{(2)} \\ (1)(2)\Rightarrow a_i.s$O(n\log n)$

代码

#include 
using namespace std;
typedef long long ll;
#define FILE(x) freopen(#x".in", "r", stdin);\
                freopen(#x".out", "w", stdout)
#define REP(i, a, b) for(int i=(a); i<=(b); ++i)
#define REPd(i, a, b) for(int i=(a); i>=(b); --i)
inline ll rd(){
    ll r=0, k=1; char c; while(!isdigit(c=getchar())) if(c=='-') k=-k;
    while(isdigit(c)) r=r*10+c-'0', c=getchar(); return r*k;
}
const int N=50050;
ll n, sum, ans;
struct cow{
    ll w, s;
    bool operator<(const cow &y) const { // 代码多简单，我不用详述了吧
        return w+s<y.w+y.s;
    }
}c[N];
int main(){
    FILE(acrobat);
    n=rd();
    REP(i, 1, n){
        c[i].w=rd(), c[i].s=rd();
    }
    sort(c+1, c+n+1);
    ans=-c[1].s;
    REP(i, 1, n){
        ans=max(ans, sum-c[i].s);
        sum+=c[i].w;
    }
    printf("%lld", ans);
    return 0;
}

T4 过路费 (cost)

CodeVS 1519 ~~我妹有打开就不贴链接了~~

题意简述

给定一个无向图，和 $q$ 个询问包含 $S, T$ 最小化 $S$ 到 $T$ 路径上的最大边权，每个询问输出这个值

分析

最小生成树+LCA

这题还算明显…吧

首先是答案路径一定在最小生成树上

简证

考虑两点间有多条路径

如图中 4, 2 两点有 <4, 5, 1, 2> 和 <4, 3, 2> 两条路径

而考虑最小生成树的过程

删去的边的端点一定由比它小的边连通

所以走树边的路径的最大边权一定小于其他路径的最大边权

（因为小于其中被删的边的边权）

证必

至于树上路径最大边权可以类似 LCA 的倍增方法，在维护一个 $mx[i][j]$

表示从 $i$ 点向上 $2^j$ 所经过的路径的边权最大值

更新方法

mx[i][0]=(i, fa[i]).v

mx[i][j]=max(mx[i][j-1], mx[pa[i][j-1]][j-1]);

$O(m\log m+q\log n)$

代码

#include 
using namespace std;
typedef long long ll;
#define FILE(x) freopen(#x".in", "r", stdin);\
                freopen(#x".out", "w", stdout)
#define REP(i, a, b) for(int i=(a); i<=(b); ++i)
#define REPd(i, a, b) for(int i=(a); i>=(b); --i)
inline ll rd(){
    ll r=0, k=1; char c; while(!isdigit(c=getchar())) if(c=='-') k=-k;
    while(isdigit(c)) r=r*10+c-'0', c=getchar(); return r*k;
}
const int N=10010, M=100010;
ll n, m, q, mx[N][30];
int fat[N], dep[N], pa[N][30];
typedef pair<int, ll> pil; 
vector<pil> g[N];
struct edge{
    int a, b; ll w;
    bool operator<(const edge &x) const {
        return w<x.w;
    }
}e[M];
int find(int x){
    return x==fat[x]?x:fat[x]=find(fat[x]);
}
void kruskal(){
    sort(e+1, e+m+1);
    REP(i, 1, m){
        int a=e[i].a, b=e[i].b, w=e[i].w;
        if(find(a)!=find(b)){
            g[a].push_back(make_pair(b, w));
            g[b].push_back(make_pair(a, w));
            fat[find(a)]=find(b);
        }
    }
}
void dfs(int x=1, int fa=0){
    dep[x]=dep[fa]+1; pa[x][0]=fa;
    REP(i, 1, 16) pa[x][i]=pa[pa[x][i-1]][i-1], mx[x][i]=max(mx[x][i-1], mx[pa[x][i-1]][i-1]);
    for(vector<pil>::iterator i=g[x].begin(); i!=g[x].end(); ++i)
        if(i->first!=fa){
            mx[i->first][0]=i->second;
            dfs(i->first, x);
        }
}
ll lca_max(int x, int y){
    if(dep[y]>dep[x]) swap(x, y);
    int tmp=dep[x]-dep[y]; ll res=0;
    REP(i, 0, 16) if(tmp&(1<<i)) res=max(res, mx[x][i]), x=pa[x][i];
    REPd(i, 16, 0){
        int xx=pa[x][i], yy=pa[y][i];
        if(xx!=yy){
            res=max(res, mx[x][i]), res=max(res, mx[y][i]);
            x=xx, y=yy;
        }
    }
    return x==y?res:max(res, max(mx[x][0], mx[y][0]));
}
int main(){
    FILE(cost);
    n=rd(), m=rd();
    REP(i, 1, n) fat[i]=i;
    REP(i, 1, m) e[i].a=rd(), e[i].b=rd(), e[i].w=rd();
    kruskal();
    dfs();
    q=rd();
    while(q--){
        int s=rd(), t=rd();
        printf("%lld\n", lca_max(s, t));
    }
    return 0;
}

T5 加工零件 (work)

P5663 [CSP-J2019] 加工零件 - 洛谷计算机科学教育新生态 (luogu.com.cn)

题意简述

太长了，简述不了，自己看上面的链接

分析

分层图最短路

对于 $a$ 到 $1$ 号节点，如果有一条路径是偶数

如图，$5$ 到 $1$，上面那条路径长度是偶数

所以只要 $L-4, L-6, L-8, …$ 中有一个为 $0$ 即需要提供原材料

等价于

\[L\in \{x:x=2k,x\ge E,k\in Z\}\]

其中 $E$ 表示这条路径边数

若路径长为奇数

等价于

\[L\in \{x:x=2k+1,x\ge E,k\in Z\}\]

其中 $E$ 表示这条路径边数

要尽可能满足 $x \ge E$ 的条件，取最短路即可

所以只需找出 $1$ 到 $a$ 的奇数最短路和偶数最短路

考虑分层图

将原来的点 $i$ 拆成 $i,0$ 和 $i,1$ 分别代表到 $i$ 时路径为偶数和奇数

将原来的边 $i-j$ 改成 $i,0-j,1$ 和 $i, 1-j,0$

然后以 $1, 0$ 为原点跑单源最短路，这里边权唯一所以跑 BFS 即可

当然你跑 Dijkstra 或 SPFA 也行

这里其实可以建图时按原图建，跑 BFS 时当作分层图跑

BFS：$O(n+m+q)$

代码

#include 
using namespace std;
typedef long long ll;
#define FILE(x) freopen(#x".in", "r", stdin);\
                freopen(#x".out", "w", stdout)
#define REP(i, a, b) for(int i=(a); i<=(b); ++i)
#define REPd(i, a, b) for(int i=(a); i>=(b); --i)
inline ll rd(){
    ll r=0, k=1; char c; while(!isdigit(c=getchar())) if(c=='-') k=-k;
    while(isdigit(c)) r=r*10+c-'0', c=getchar(); return r*k;
}
const int N=1e5+10;
ll n, m, q, d[N][2], l;
int a, b, v[N][2];
char ans[2][10]={"No", "Yes"};
vector<int> g[N];
#define pb push_back
struct node{
    int u, f;
    node(int u, int f):u(u), f(f){} 
};
void bfs(){
    memset(d, 0x7f, sizeof(d));
    memset(v, 0, sizeof(v));
    queue<node> p;
    d[1][0]=0; v[1][0]=1;
    p.push(node(1, 0));
    while(!p.empty()){
        node u=p.front(); p.pop();
        for(vector<int>::iterator i=g[u.u].begin(); i!=g[u.u].end(); ++i){
            node y=node(*i, 1-u.f); // 按照分层图转移
            if(v[y.u][y.f]) continue;
            d[y.u][y.f]=d[u.u][u.f]+1;
            v[y.u][y.f]=1;
            p.push(y);
        }
    }
}
int main(){
    FILE(work);
    n=rd(), m=rd(), q=rd();
    while(m--) a=rd(), b=rd(), g[a].pb(b), g[b].pb(a); // 建原图
    bfs();
    while(q--){
        a=rd(), l=rd();
        // 条件判断
        printf("%s\n", ans[((l&1)&&l>=d[a][1])||((l%2==0)&&l>=d[a][0])]);
    }
    return 0;
}

T6 奶牛政坛 (Cow Politics)

P2971 [USACO10HOL] Cow Politics G - 洛谷计算机科学教育新生态 (luogu.com.cn)

题意简述

给定一颗树，每个节点都属于某一个集团，而且每个集团至少包括两个节点。求每个集团离得最远的两个节点（沿着双向道路行走）的距离。

分析

直径+LCA

这题考场时觉得毫无头绪

看了题解发现这么简单

根据直径的性质，可以类似知道以一个根结点到每个集团内深度最深的点一定是每个集团内的“直径”中的端点

将其作为其集团的代表

求集团内每个点到他的距离取最大值即可

求距离可用 LCA 求

$O(n\log n)$

代码

#include 
using namespace std;
typedef long long ll;
#define FILE(x) freopen(#x".in", "r", stdin);\
                freopen(#x".out", "w", stdout)
#define REP(i, a, b) for(int i=(a); i<=(b); ++i)
#define REPd(i, a, b) for(int i=(a); i>=(b); --i)
inline ll rd(){
    ll r=0, k=1; char c; while(!isdigit(c=getchar())) if(c=='-') k=-k;
    while(isdigit(c)) r=r*10+c-'0', c=getchar(); return r*k;
}
const int N=200010;
ll n, k, a[N], ans[N], f[N], p, rt, pa[N][30], dep[N];
vector<int> g[N];
void dfs(int x=rt, int fa=0){ // 普通的 DFS
    dep[x]=dep[fa]+1; pa[x][0]=fa;
    REP(i, 1, 20) pa[x][i]=pa[pa[x][i-1]][i-1];
    for(vector<int>::iterator i=g[x].begin(); i!=g[x].end(); ++i){
        dfs(*i, x);
    }
}
int lca(int x, int y){ // 普通的 LCA
    if(dep[x]<dep[y]) swap(x, y);
    int t=dep[x]-dep[y];
    REP(i, 0, 20) if(t&(1<<i)) x=pa[x][i];
    REPd(i, 20, 0){
        int xx=pa[x][i], yy=pa[y][i];
        if(xx!=yy) x=xx, y=yy;
    }
    return x==y?x:pa[x][0];
}
int main(){
    FILE(cowpol);
    n=rd(), k=rd();
    REP(i, 1, n) a[i]=rd(), p=rd(), g[p].push_back(i), rt=p==0?i:rt;
    dfs();
    REP(i, 1, n) if(dep[f[a[i]]]<dep[i]) f[a[i]]=i; // 每个集团的最远点
    // 集团距离更新
    REP(i, 1, n) ans[a[i]]=max(ans[a[i]], dep[i]+dep[f[a[i]]]-2*dep[lca(i, f[a[i]])]);
    REP(i, 1, k) printf("%lld\n", ans[i]);
    return 0;
}

T7 先咕着

你好

2023-07-17T00:00:00+00:00