yjjr's blog

Au revoir, 2019!

Wed, 18 Dec 2019 00:00:00 +0000

https://yangjijingru.com/img/2019.mp3

———— 《Payphone》+《We are young》+《太阳》

突如其来的吐槽

已经半年多没有更过博客了，反正估计也没什么人看，我也没时间更博

这篇意识流2019总结文写于冬假回国途中，冬天从瑞士回国经过深圳转机，这真的是一件需要勇气的事

深冬的达沃斯-10°C，温暖的深圳23°C，最后回到合肥5°C，真的是在一天内体验到了北半球的春夏秋冬

每次转机回国自己都嫌弃自己邋遢的样子TAT

凑活着看吧

2019年经历了太多太多思想和身份上的转变

年初的时候想着去念IB，之后去申请英联邦国家大学，大概当时是由于不想学德语了吧

春天之后又转变去找Matura的瑞士高中，当时的自己还是太young。。。

转眼到了五月份，一个重要的时间节点

去了斯洛伐克参加欧洲奥赛培训，每场模拟赛结果都还可以（甚至在瑞士队伍里可以说是十分优秀）

结果最终却冷门无缘瑞士国家IOI队，拿了个银牌滚回国，同时也结束了过去一年的AFS交流年

之后便是三周愉快的国内高中毕业学考准备，在合六度过了一段愉快的时光

暑假开始学习了法语，认真为Matura考试做准备，从此我也是掌握四门语言的人了（貌似这个技能很加分）

从八月底又去了瑞士开始了留学生活，然而现在看来似乎是开始了一段畸形的日子

各种各样生活和学习上的压力，尤其是一个人的孤独，这一点远超出我之前的想象

九月底秋假回国，十一月由于运动受伤又紧急飞回国做了个手术

十二月的时候心理状况有些崩溃，但回国之后又恢复了正常吧

总之，这是我18年以来最艰难的一年了，也远比去年交流年的压力要大

学业上，告别了OI，全力以赴准备Matura考试，当然其中也有很多乱七八糟的学业规划与念头，但最终都打消了

太懒了

过于懒惰，并且回国转机之旅过于疲惫，貌似也没什么可以总结的了

还是把更多的时间投入到学习中比较好，毕竟离毕业考试也就只剩40天了

沉迷学习，乐此不疲qwq

Au revoir, 2019!

放一些有纪念意义的图片吧（连图片评论都懒得写了）

Soi final training

Sun, 26 May 2019 00:00:00 +0000

本文长文/高能预警

由于博主过于懒惰和菜鸡，打算把未来50天内的大多数训练题目全部放在此博文中，将会不定时更新

所有代码全部位于Onedrive共享文件夹内

DP

CF802K 树形DP

无意中做到了瑞士HC2 EPFL的题目，果然很SOI，很侧重思维性

题意：给定一棵树，可以从一个点开始在树上行走，每条边上有一个宝物价值为$w$，每个节点最多访问$k$次，求能够得到的最大价值

$f[x][1]$表示访问完以$x$节点为根的子树后返回到$x$的父节点所能得到的最大价值

$f[x][0]$表示访问完以$x$节点为根的子树后不返回$x$的父节点所能得到的最大价值

CF261D 结论+暴力

题意：给出数列$B$，请假定一个数列$A$，使得其长度为$n\times t$，使得$A$序列为若干个$B$组成，求出序列$A$的最长上升子序列数

表面上看十分不可做，无法把$A$序列求出来并计算LCS

但显然当$t\geq min(n,maxb)$时，答案是$a$中不同的个数

剩下的可以直接暴力

因为LCS的总增量一定小于等于$maxnb\times n$

CF285D DP+容斥+组合

题意：$n$个数的全排列$p_i$，对于每个全排列$p_i$，若$abs(p_i - 1)=1$，则位置$i$为好，询问$n$个数的全排列中存在多少个恰好$k$个好位置的排列

设$f[i][j][0/1][0/1]$表示前$i$位，存在至少$j$个位置满足条件的计数值，两个$0/1$分别表示数字$i$有没有使用过和数字$i+1$有没有使用过

每次转移判断该位置是否满足条件，如果不满足条件的话就添加一个空数字（可以直接乘上阶乘）

但这样的排列中还会存在一些大于$k$个好位置的排列，所求的为至少$k$个好位置

要得到最终的答案还需要一个trick

存在一个容斥原理的模型

$ans=f[n][k]-C(k+1,k)\times f[n][k+1] + C(k+2,k)\times f[n][k+2]……C(n,k)\times f[n][n]$

因为取模数较大为$1e9+7$，所以只能使用逆元处理

CF50D 二分+概率DP

题意：给定若干点和一个爆炸中心点的位置坐标，如果要想使得其爆炸失败（小于$k$个点爆炸）的概率满足不大于给定值$F/1000$，求出最小爆炸半径

很明显先二分答案之后概率DP检验

$f[i][j]$表示前$i$个坐标中存在$j$个爆炸的概率

只需要枚举是否爆炸进行状态方程的转移即可

时间复杂度$O(T\times n^2)$

线段树

CF482B 线段树+位运算

题意：给出序列的长度$n$和$m$次询问，对于每次询问给出$l_i,r_i,q_i$，满足$a[l_i]\& a[l_i+1]\& … \& a[r_i] = q_i$，请你求出原序列${ a_i }$

先按照题意给出的询问将原数组修改，之后再次询问一次看是否符合条件

注意线段树操作的时候要把极大值inf每一位都赋值为1（在这里WA了半小时）

CF833B DP+线段树优化

题意：给出长度为$n$的序列，可以将其划分为$k$段，最大化每段中出现的不同种类数字个数之和

用$f[i][j]$表示前$i$个书分为$j$段的最大价值

$f[i][j]=\max { f[k][j-1]+query(k+1,i) } (0\leq k < i)$

然后发现从$a[i]$上次出现的位置$lst[a[i]]$到当前位置中的这些$f$值都需要$+1$，那么可以第一重循环枚举$K$，之后每次重构线段树进行优化

时间复杂度$O(nk\log n)$

CF383C dfs序分层+线段树

题意：给出长度为$n$的序列，支持如下操作：

查询一个点权值
修改以这个点$x$为根的子树中所有节点的权值，奇数层+val，偶数层-val

先dfs将树中每个节点分层，之后记录两个权值，分别是对应的+/-答案

CF633H

题意：给出长度为$n$的序列，每次询问给出$l_i,r_i$，请求出$a[l_i]…a[r_i]$之间的斐波那契权值

其中斐波那契权值定义为：将子序列排序去重，$P(a)=a_1\times F(1) + a_2\times F(2) + … + a_i\times F(i)$，其中$F(i)$指斐波那契数列

莫队处理询问，线段树处理修改和答案

对于莫队，由于区间内的数和顺序和数量无关，所以可以看成集合进行操作

首先离散化并对每个数进行计数，只有数量在$0$和$1$之间变化时才进行线段树的答案修改操作，否则实际上对答案无影响

对于线段树，pushup可以使用矩阵完成

其中$[1][2]$是答案的矩阵，$[2][2]$是$fib$的矩阵

结果发现常数优秀的暴力可以水过去。。。。

树

CF686D 树的重心

题意：给出大小为$n$的树和$q$次询问，每次询问以$x$点为根的子树中重心的编号

当合并两棵树的时候，新的树的重心一定在原本的两个重心的路径上

CF191C 树上差分

题意：给出大小为$n$的树和$m$次操作，每次操作将路径上的边都染色一次，最后询问每条边被染色的次数

将$(x,y)$节点$+1$，$lca(x,y)$节点$-2$，最后统计前缀和即可

CF842C

题意：给出大小为$n$的树，每个节点的权值为$a[i]$，询问每个节点到根节点的路径上所有点权值的最大公约数$gcd$，其中你可以把路径上一个节点的权值变为$0$，使$gcd$最大化

经典

HDU1028 母函数/DP

母函数学习课件

本题母函数$(1+x+x^2+x^3+x^4+…)\times (1+x^2+x^4+x^6+…)\times (1+x^3+x^6+x^9+…)…$

DP方法

$f[i][j]$表示把自然数$i$划分为所有元素不大于$j$的方案数

$f[i][j]=f[i-j][j]+f[i][j-1]$

POJ2442 堆/优先队列

题意：给出$n$个长度为$m$的数列，一共$m$次让你每次从各个数列中选一个数相加成新的数列，让你求该数列的前$n$小的值

每次将前$i-1$行求出的$n$个最小值和第$i$行的前$n$小值求和放入优先队列

HDU1010 DFS+奇偶性剪枝

题意：给出迷宫入口出口，询问能否恰巧在$k$步的时候到达出口

常规DFS+剪枝

如果已经存在解
当前距离超过$k$
当前点到出口最小距离过长
当前点到出口最小距离的奇偶性与答案不符

POJ1742 多重背包可行性

常规多重背包三重循环

如果只需要检测可行性，只需要两重循环

每次对选取的次数进行限制即可

POJ2411 状压DP

题意：给出$n\times m$的矩形，用$1\times 2$的方块覆盖，不重叠并且要求完全覆盖，不能越界，询问完全覆盖的方案数

设计状态$f[i][S]$表示第$i$行状态为$S$时的方案数

对于横放，我们可以将两块砖都设计为$11$

对于竖放，为了防止冲突，将上面的设为$0$，下面的设置为$1$

之后逐格讨论状态即可，要手动移动循环变量

POJ2255 二叉树遍历

给定先序和中序遍历，求出后序遍历

直接递归即可

SGU199 LIS输出解

二维LIS，按指定域排序后，求出最长上升子序列

少女峰之北，比尔湖之南

Sat, 18 May 2019 00:00:00 +0000

https://yangjijingru.com/img/swisslife.mp3

————《蜂鸟》von 吴青峰

眨眼即逝的春假

记录下最浪的一个春假

Luzern, Freiburg, Basel, Zürich, Davos, Lausanne, Interlaken, Thun, Mürren, Bern

竟然挤时间追了两部剧《耀眼》《与恶》，都是催泪的剧啊TAT

还有时间读完了两本文学作品，都不知道从哪来的这么多空闲时间

三周后的SOI决赛，一个月后的德福考试

把手机里的娱乐社交软件都卸了，断了某乎

未来一个月估计会6127沉迷学习吧（比996还拼啊）

这篇博文会暂时停更了，下次更新估计等我回国后了

不多说上图了

一段耀眼的时光

深夜刷完了今年热门韩剧《耀眼》

身为一个男生真的第一次看韩剧看哭

刚看完大结局的我反射弧较为混乱

感触真的很深很深，可是身为一个工科男无法描述

和爸妈通电话时候经常抱怨一个人在外的留学生活十分艰苦

在离开达沃斯的火车上半梦半醒地回忆过去的一段时间，真的发生了太多太多的事情

会在大街上领麦当劳的优惠券，去快餐馆学会了点今日特价套餐

尽管在瑞士已经待了九个月，但很多时候和人用德语交流还是一脸懵

每天早上五点多起来背德语，深夜抽空练习Codeforces的模拟赛

一个人从超市提着三大袋子的食材回家，学会了DIY火锅，还和妈妈面前自豪地夸奖自己的厨艺

每当欧洲时间的深夜，总是会很想念欧亚大陆另一端的你们，第一次深切体会到对家乡炙热的思念

也如季羡林先生在《留德十年》里所说：当我出了国之后有两个母亲，一是祖国，二是自己的生母

对这两个母亲的思念是一点也不假的

在过去短短的不到一年时间里，自己做了很多很多在国内从来不可能有机会去体验的事情

虽然一切都很苦很累，但当十年后，当我成家立业之后，当我年迈之时，再次回忆起这段在瑞士的留学生活，相信一定是笑中带泪的满足和美好吧

毕竟自己才17岁，正值青春年少，风华正茂，还有时间去拼搏

最平凡的日子最耀眼，哭着笑着，这就是人生。

无论幸运还是不幸，都要活在当下，这样的你才是最耀眼的。

最近去了趟德国首战德福，感觉会得到四个Unter3 实力太菜

然后去了两个旅游景点参观学校 Engelberg和Davos

然而却沉迷在了Luzern的美景中，不多说上图了QwQ

身为一个南方孩子，第一次在四月份见到厚度为1m的积雪，长见识了啊

在Luzern湖边长椅上思考人生真的是一件妙事

每天努力完成学习任务，还有六周，加油！

不愚的愚人节

SOI的第一次Final Workshop结束了，感悟又有很多

自己在IOI赛制中的比赛策略还是存在很大的问题，应该好好反思下这个大问题了

依然存在题目理解障碍的问题（可能是做习惯了CNOI的题目，不习惯EUOI的脑回路）

感觉自己的水平还不足以稳进国家队，在决赛前必须要把自己的能力再提升两个level

未来50天真的要拼了，不能再用划水的心态对待OI了，毕竟这是六年OI生涯来离IOI最近的一次，不想错失这最后的机会了

虽然今天是愚人节，但萌生了一个不愚的想法：回国前过德福+入选国家队，希望这两者都能实现

每天1h背德语单词+1h德福练习+2.5h OI training

准备拿出中高考的努力来拼一把了，也就只有50天而已嘛！

找私立学校也终于有了不小的进展，一切都越来越顺利的四月

虽然Gym Neufeld的老师不是很建议我去读Matura（主要是因为德语和法语问题），但一切选择都要遵从自己的内心

依然很自信，自己一定可以在一年内通过Swiss Matura的

选择没有好坏，只会遇见更好的自己（这句话好鸡汤好励志的感觉hhh）

每天清晨去洛桑EPFL的火车上总是可以看到莱蒙湖，真的好喜欢洛桑啊qwq（~~话说本来还打算在洛桑读两年IB的~~）

还有2018-2019年瑞士冬令时最后一个傍晚在Lausanne Gare抓拍的紫（橙）色落日（超级nice的）

春天的来临

真的还有不到60天就要回国了呢

时间总是一晃而过

SOI Second Round总算是挺过来了，虽然得分十分玄学（理论题莫名其妙地爆零）

肝了半个月的德语，只得出一个结论：德语比中文难学的多（我宁愿去学文言文，坐等回国后学考打脸qwq）

和几个私立Matura学校联系地并不是很顺利（只能说是水逆时期很糟心了吧）

幸亏我OI还没凉

同时也没有考虑好到底是去念IB还是继续在瑞士念Matura

比较忙等有时间再慢慢更，先咕成这样吧qwq

附上一张伯村春景，最期待放春假可以在下午去玫瑰园躺椅上晒太阳喝咖啡,nice!!!

After SOI Second Round

真的是一个感慨万千的周末

周五晚上其实挺紧张的，毕竟第二天要参加2P了，只有一次的机会（虽然AH省选也只有2次而已）

之后还算满意拿了80+50+50+100=280吧，吸取了教训，以后尽量不要肝数学题qwq

自己在IOI赛制中代码能力还是弱了些，以后还是要多练习IOI赛制

这个分数入围决赛应该没问题了qwq（但愿吧）

之后看到了国内大学自招政策的变化，大概对于中学生竞赛来说可能是一个时代的完结（虽然竞赛的本因应该是兴趣）

不做过多评价，只能祝国内竞赛生高考加油QwQ

感触最深的还是身边某位大佬物竞决赛失利了吧，竞赛和人生就是如此，有些事情就是意想不到地发生了

在现在这个环境下（无论是国内还是国外），支持竞赛党走下去的恐怕只有自己的喜爱和兴趣了

当我们每天投入巨大的精力去备赛的时候，都曾幻想过稳拿省一，参加国际奥赛的场景吧，然而现实往往使自己菜醒

每年都存在很多公认实力很强的选手翻车，但这就是奥赛，或许也就是其精彩之处

虽然每天拼命地刷OI题，但也许在赛场上就会因为思维题/智商题/结论题GG

也许真正比拼的就是心态吧…

三月的Second Round，五月的Final Round，能否进队感觉不是那么重要了呢qwq

人生只有三种道：上坡道，下坡道，想不到。

渺小的我们永远不知道明天会发生什么，只能努力做好自己该做的事情，结果随它去吧

三月的狮子

三月是春天的开始，也暗示着人生的开端，会面对各种改变，也拥有无限可能。

March comes in like a lion and goes out like a lamb.

转眼又是半个月，已经是三月的中旬了

三月的伯村已经有了些春天的气息（虽然还是很冷，时而暴雪）

欧洲这时候依然吃不到甜草莓，咕咕咕（还是想念合肥的草莓）

经过半个月的考虑，还是倾向于留在瑞士念Matura（~~对不起SG那所给了我offer的学校~~）

现在才明白《问题餐厅》里的台词

当迷茫的时候，要选择难走的那条路。

可能在两个月前追剧的时候，依然很迷惑，既然都很迷茫了，怎么去选择

两个月之后才明白这句话的意义吧

这句话并不是要你在迷茫的时候强迫自己选择，而是希望不要让自己选择那条轻松的路径

很多人在迷茫的时候总想要退缩，大部分人都心怀梦想，当对于眼前的困难有畏惧心理时，就会想选择简单的路

本质上大概是希望大家不忘初心吧

当然每个人都有自己不同的理解qwq

虽然Matura和IB比起来对我很难，但相信自己可以顺利毕业

已经做好了同时学习英法德三种语言的准备QWQ

准备了半个多月的2T感觉考得海星，当然还剩下一半的2P，但愿能够入围吧（不然就要退役了）

从六年前那个夏天的OI入门，源于兴趣，这个春夏，也终于热爱吧

现在可以说是对于OI已经毫无升学手段的念头了，只是单纯的喜好而已

无论结果如何，都是我的人生（~~总感觉这句话过于成熟hhh~~）

二月的尾声

开始一大堆意识流碎(xia)碎(bi)念(bi)

大年初三和住家爷爷奶奶去巴塞尔玩了一天，看了毕加索的画展

结果唯一感受是Basel比Bern要更国际化，然后喜欢上了Basel和莱茵河

之后紧接着去Sarnen参加了为期一周的SOI Camp，又重新体会到伯村的好

每次当火车回到Bern HauptBahnhof时，看到远处的少女峰，竟然会有回家的感觉了，大概真的把这里当成了第二个故乡了吧，莫名其妙地感动

在Camp里认识了另外一个中国小哥，真心佩服他有勇气参加Matura Prüfung，我还是去认怂读IB吧

SOI Camp五十个选手，安排了5个十人房（人生第一次住大通铺，自己还很sb选了上铺）

~~坚持了一周没洗澡~~ 好像暴露了什么qwq

每天就是面包oder意面（真的不喜欢一部分Pasta）

总之生活体验上是来瑞士之后最差的一周了（摔）

如果中国咕咕F能给SOI捐点赞助费就好了

然后见到了来自以色列/罗马尼亚的国际金牌/银牌，考试被几位金银牌虐了惨惨（本来还想着Rank1的）

但是展示了一波中国CNOIer强大的数据结构本领hhh

只是一个很Naive的询问第K小值问题，随手敲了个树状数组套主席树拿了全场最高分，中国果然是数据结构大国tql

Sarnen的景色的确超赞（感觉比Interlaken要好看多了）

之后又是一个人的元宵节，过完了正月十五才算过完了年呐

二月真的是在疯狂地赶工中度过的

SOI Camp/Second Round, Deutsch lernen, Presentation, FRC, IB Admission

之后又是一个怀疑人生的周末

真的菜醒啊（大哭）

去Altdorf给机器人编程（在路上半个公交车的中国人还被全程当成了日本人hhh）

和Partner Debug Failed之后躺在床上仰望天空，真的开始怀疑人生。。。

物理大佬和编程大佬依然无法解决的问题（之后开始小声哔哔该如何背锅甩锅的问题）

爆肝了两天一夜，结果最后依然GG，依然不知道下周该怎么去Istanbul比赛啊，真的很醚

山里的景色都很美，但也看腻了吧，只有刚来瑞士的两个月觉得比较惊艳了

一个忙碌的二月，一个艰难的二月

也许三周后OI就会退役了，也许是三个月后，或许（也希望）是这个夏天的八月

无论今年的OI比赛结果如何，无论是在何处，已经决定好明年不再参加了吧

OI生涯终于要在2019年结束了呢

认为张老师讲的“边界效应”很有道理

当了解一个东西过于透彻，收获所得将远远小于付出的精力，学习过程中飞跃性最大的时期莫过于初始的阶段

所以打算退役之后转向大学申请和工程类项目的学习了

（以下估计没人看的部分）

十分感谢FRC7628的所有队员

作为一支无导师的海外新人队伍，需要克服的困难比国内大得多得多，可能是国内人员远远无法想象的

第一年能做到这样，已经真的很好很好了

无论是SOI没有实力AK，还是FRC的经历，都让我意识到了技术的重要性

情商和财力固然重要，但技术是成败的关键

再次感谢YR，十分高兴能够在瑞士认识你们一群同龄中国人，并且能够收获这样一段经历（可以用Adventure来形容了吧）

还有Oscar，很能聊得来的一个物理大佬，每次总是很能聊得来，这大概就是原本正经的学霸充满“机械的味道”了吧（这个梗很可以）

All the best for you!!!

2019.02.07

一个人过完了农历新年

过去一周看过了全瑞士的暴雪，一群人的联邦宫，三个人的火锅，一个人的年夜饭

过年前一个人把从中国带来的剪纸贴在了卧室的窗上，一个人在年二十九的晚上吃年夜饭，在瑞士不像英美加能感受到过年气氛，自己一个人安安静静也挺好

年三十下午第一次认真地看完了春晚全程，和父母视频拜年，2019年我也终于要迎来自己的18岁了，18岁的生日或许在SG或许在CH，又是前路未知

这个春节没有烟花，没有亲朋好友的年夜饭，没有长辈们真实的红包，希望2020年的春节可以在家和父母在一起团聚吧

过于焦虑导致失眠了几天，之后询问了几所国际学校，列了未来两年申请大学的计划，感觉未来不是那么遥远了呢，学会了和自己和解

又是一个忙碌的二月，一个又一个deadline…

2019.01.31

成功在一月的最后一天心态崩溃，负能量满满的一天

原因大概有很多

也许是本身最近因为FRC编程的事情挺烦燥，还有2019秋季申请的一堆破事，当然也有关于SOI训练的自身问题

导致心态崩溃的最后一根稻草大概就是五月份很多重要日程的大变动吧（~~或许主要是寻找新的国际学校的烦心事~~）

算是来瑞士之后的第三次心态崩溃，前两次分别是生活关和语言关，这次主要是因为学业压力吧

之后和父母一天内总共视频了4h（时间最长的一次了吧）

心情虽然很糟，但看了日剧之后又很燃

很喜欢坂元裕二的台词

对别人温柔就能对自己温柔，去了解别人便可了解自己，爱上别人的笑容，自己也会绽放微笑，要靠自己成就自己。

不甘心的时候，就是在进步，痛苦的时候，就是在成长。

当感觉迷茫的时候，要选择那条艰难的路。

———《问题餐厅》

手机里删了很多容易分心的APP，断了很多社交软件

剩下的100天真的要认真学习了

毕竟人是要靠自己成就自己的嘛！

在瑞士的第一个寒冬就快过去了，期待二月能有一个好的开端。。。

一个人，在伊蒂根，等待着春天的到来

2019.01.26

2018-2019学年的第一学期终于结束了，迎来了三周（只属于我）的特殊假期

夜里看《歌手2019》，看杨坤唱《下个路口见》真的要笑抽，怎么会有这么可爱的大叔啊

吴青峰真的是“在孤独星球上看日落的小王子”

吴青峰版本的《起风了》把冬天唱成了春天，把离别唱成了相遇，最惊艳的莫过于“一笑生花”的温柔了

“Le vent se lève, il faut tenter de vivre.”

“纵有疾风起，人生不言弃。”

“我曾难自拔于世界之大，也沉溺于其中梦话，不得真假不做挣扎不惧笑话”

世界那么大，我相信，我的野心再大，它也能装得下

尽管未来的120天会很忙碌，会很有挑战性，但依然要努力前行

读完了季羡林先生的《留德十年》，感触颇深

大概算了一下，我在瑞士估计也得留学七/八年吧

在德语区留学虽然很无聊（个人感觉瑞士可能比德国更无聊），生活极其规律，极其平静，的确是个适合学术研究的地方

季老先生的十年一梦，语言十分平实了，但是这正符合德国人的平平淡淡生活

不知道多年之后，又会是怎样来回忆自己的留学生活

也许一年前做出留学决定之时只是源于“难自拔于世界之大”和“不惧笑话”，但现在越发肯定自己的选择

无论前路如何，既然选择了这条路，在目前的环境下，只能奋勇向前了，也不曾后悔。。。

2019.01.20

抱歉，又一次变成了月更（貌似还是两月一更）

这个日记不会再咕下去了，一定会常更的（貌似立了个flag）

和住家一起去玩了伯村的密室逃脱游戏，全程德语懵逼啊（手动一万脸蒙蔽）

雪后的伯村真的美，最喜欢每天早晨课间在学校的天台看雪山

联邦宫和时钟塔，远处的雪山，瑞士大概就是随手一拍都是风景图hhh（发pyq绝对超多赞）

离国内的春节只有两周时间了，晚上一个人还是挺想念合肥的，虽然都已经出国5个月了

2018.11.23

抱歉，再一次变成了周更，但愿我还能更下去不会咕咕咕

回瑞士的第一周ende！

乱七八糟的琐事大概都有解决思路了吧

SOI First Round1大概忙完了，下周开始肝德语了

伯尔尼的雪雾雨真的是说来就来，都不带提前预告的那种

2018.11.16

上周回国参加NOIP2018，身为划水选手，给学弟造了一套清新不毒瘤的模拟题hhh

在国内步行街看人来人往，和同学吃火锅（梁猪猪真的够铁啊，翘课来陪我吃饭），和教练喝下午茶

回国吃了大闸蟹和火锅，陪母亲过完了生日，见证了父母的纪念婚礼，拍了全家福，2018回国之旅无憾了

和父母在浦东机场T1说完那句“明年见”之后坚定地进入边检，又一次离开了中国

开贴记录未来200天的生活

每次从一个家到另外一个家都要辗转近30小时，合肥->上海->阿姆斯特丹->苏黎世->伯尔尼

回到瑞士后还是有点莫名其妙地丧，可能是因为刚离开家吧

珍惜未来的200天！

Codeforces#554 div2 solution

Wed, 24 Apr 2019 00:00:00 +0000

A. Neko Finds Grapes

题意

给出长度为$n$的序列$a_i$和长度为$m$的序列$b_i$，询问最多有多少组$a_i+b_j$和为奇数

分析

分别统计下每组中奇偶个数即可

Code

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(i,x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
int n,m,ans,a1=0,a2=0,b1=0,b2=0;
int main(){
    n=read(),m=read();
    rep(i,1,n){
        int x=read();
        if(x%2==1)a1++;else a2++;
    }
    rep(i,1,m){
        int x=read();
        if(x%2==1)b1++;else b2++;
    }
    ans=min(a1,b2)+min(a2,b1);
    cout<<ans<<endl;
    return 0;
}

B. Neko Performs Cat Furrier Transform

题意

将数字$x$通过一系列操作变成$2^k-1$

操作如下：

奇数次的操作$x \oplus 2^n-1$
偶数次的操作$x+1$

构造长度小于$40$的操作序列

分析

按照位数处理即可，每次二进制中相邻位发生$01$变化时要进行一次奇数操作

Code

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(i,x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
int ans[46],n,x,pos,tot=0,A[46],num=0;
int main(){
    x=n=read();
    rep(i,1,30)if((1<<i)>n){pos=(1<<i)-1;break;}
    int p=0,cnt=0;
    while(x){
        p++;
        int opt=x%2;
        x>>=1;
        if(x%2!=opt)ans[++cnt]=p;
    }
    cnt--;
    int j=cnt;
    while(n<pos){
        n=n^((1<<ans[j])-1);A[++num]=ans[j];
        tot++;
        if(n<pos)tot++,n++;
        j--;
    }
    cout<<tot<<endl;
    rep(i,1,num)cout<<A[i]<<' ';cout<<endl;
}

C. Neko does Maths

题意

给出数字$a,b$，请你最小化$LCM(a+k,b+k)$，求出$k$

分析

$LCM(a+k,b+k)=\frac {(a+k)\times (b+k)} {gcd(a+k,b+k)}$

即要最大化$gcd(a+k,b+k)=gcd(b-a,a+k)$

那么我们可以暴力枚举所有$1->(b-a)$的因数进行判断，求出最小值

时间复杂度$O(\sqrt {b-a})$

Code

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(i,x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
ll a,b,k;
inline ll gcd(ll a,ll b){return !b?a:gcd(b,a%b);}
inline ll lcm(ll a,ll b){return 1ll*a*b/gcd(a,b);}
int main(){
    a=read(),b=read();
    if(a<b)swap(a,b);
    ll x=abs(a-b),ans=lcm(a,b),ansk=0,blo=trunc(sqrt(x))+1;
    if(a==b){puts("0");return 0;}
    rep(i,1,blo)
        if(x%i==0){
            k=i-a%i;
            if(lcm(a+k,b+k)<ans){
                ans=lcm(a+k,b+k);
                ansk=k;
            }
            k=x/i-a%(x/i);
            if(lcm(a+k,b+k)<ans){
                ans=lcm(a+k,b+k);
                ansk=k;
            }
            //cout<<i-a%i<<' '<<x/i-a%(x/i)<<endl;
        }
    cout<<ansk<<endl;
    return 0;
}

D. Neko and Aki’s Prank

题意

给出括号序列的长度$N$，将所有合法的括号序列放进Trie树，求该Tried树的最大匹配（一个点最多只能属于一条边）

分析

发现Trie树中存在不少重复的子树

可以直接进行DP

设计状态$f[i][j]$表示深度为$i$，括号序列左右平衡为$j$的计数值

可以将其转移到状态$f[i+1][j+1]$和$f[i+1][j-1]$]

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

Code

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(i,x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int mod=1e9+7;
const int maxn=2e3+6;
int f[maxn][maxn],n,ans=0;
int main(){
    n=read();
    f[0][0]=1;
    rep(i,0,2*n-1)
        rep(j,0,2*n-1){
            f[i+1][j+1]=((f[i+1][j+1]+f[i][j])%mod+mod)%mod;
            if(j)f[i+1][j-1]=((f[i+1][j-1]+f[i][j])%mod+mod)%mod;
        }
    rep(i,1,2*n-1){
        if(i%2==0)continue;
        rep(j,0,2*n-1)if(i+j<=2*n)ans=(ans+f[i][j])%mod;
    }
    cout<<ans<<endl;
    return 0;
}

E. Neko and Flashback

题意

给出序列$b’$和$c’$，分别含义如下

$b_i=\min(a_i,a_{i+1})$
$c_i=\max(a_i,a_{i+1})$
$b’i=b{p_i}$
$c’i=c{p_i}$

请你求出任意一个满足条件的原序列$a$

分析

实际上发现数列$p$并没有实际作用

从每一个$b_i$向$c_i$连边，那么问题转化为是否存在一条长度为$n$的欧拉路径，可以直接$dfs$处理

注意要判断许多$-1$的情况，细节较多

Code

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(i,x) for(int i=last[x];i;i=e[i].next) 
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr****** 
const int maxn=1e5+6;
int n,m,tot;
map<int,int> a;
multiset<int> to[maxn<<1];
int ans[maxn<<4],top,d[maxn<<1],cnt,p[maxn<<4],b[maxn],c[maxn],val[maxn<<1];
void dfs(int x){
    for(auto i=to[x].begin();i!=to[x].end();i=to[x].begin()) {
        auto v=*i;
        to[x].erase(i),to[v].erase(to[v].lower_bound(x));
        dfs(v);
    }
    ans[++top]=x;
}
int main(){
    n=read();
    rep(i,1,n-1){
        b[i]=read();
        if(!a.count(b[i]))a[b[i]]=++tot,val[tot]=b[i];
    }
    rep(i,1,n-1){
        c[i]=read();
        if(b[i]>c[i]){puts("-1");return 0;}
        if(!a.count(c[i]))a[c[i]]=++tot,val[tot]=c[i];
        to[a[c[i]]].insert(a[b[i]]),to[a[b[i]]].insert(a[c[i]]);
        d[a[c[i]]]++,d[a[b[i]]]++;
    }
    rep(i,1,tot)if(d[i]&1)p[++cnt]=i;
    if(cnt!=0&&cnt!=2){puts("-1");return 0;}
    else{
        if(cnt==0)dfs(1);else dfs(p[1]);
        if(top!=n){puts("-1");return 0;}
        else{
            while(top)printf("%d ",val[ans[top--]]);
            return 0;
        }
    }
}

Agc032 solution

Tue, 23 Apr 2019 00:00:00 +0000

A - Limited Insertion

首先判断无解的情况

序列必须满足$num_{\leq a[i]} \geq a[i]$

之后每次从后面找到一个最靠后而且当前位置可以放置的，即前面正好放了$a_i-1$个数

Code

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(i,x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int maxn=106;
int a[maxn],n,num[maxn];
bool vis[maxn];
int main(){
    n=read();
    rep(i,1,n)a[i]=read();
    rep(i,1,n){
        int num=0;
        rep(j,1,i-1)if(a[j]<=a[i])num++;
        if(num+1<a[i]){puts("-1");return 0;}
    }
    rep(i,1,n){
        num[0]=0;
        rep(j,1,n)num[j]=num[j-1]+vis[j];
        dep(j,n,1)
            if(!vis[j]&&num[j-1]+1==a[j]){
                vis[j]=1;
                cout<<a[j]<<endl;
                break;
            }
    }
    return 0;
}

B - Balanced Neighbors

分为奇偶讨论

如果为$N$为偶数，那么分为$N/2$组，$(1,n),(2,n-1)…$

如果为奇数的话，那么额外处理$N$为单独的一组，$(1,n-1),(2,n-2),…,(n,n)$

之后将相邻的两组之间连边即可

Code

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(i,x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int maxn=106;
int n,num=0;
struct node{int x,y;}a[maxn],ans[maxn<<4];
void Wri(int X,int Y){
    ans[++num]=(node){a[X].x,a[Y].x};
    ans[++num]=(node){a[X].x,a[Y].y};
    ans[++num]=(node){a[X].y,a[Y].x};
    ans[++num]=(node){a[X].y,a[Y].y};
}
int main(){
    n=read();
    if(n%2==1){
        rep(i,1,(n-1)/2)a[i]=(node){i,n-i};
        a[n/2+1]=(node){n,n};
        //rep(i,1,n/2+1)cout<<a[i].x<<' '<<a[i].y<<endl;
        rep(i,1,n/2-1)Wri(i,i+1);
        ans[++num]=(node){a[n/2].x,a[n/2+1].x};
        ans[++num]=(node){a[n/2].y,a[n/2+1].x};
        if(n/2+1>2)ans[++num]=(node){a[1].x,a[n/2+1].x},ans[++num]=(node){a[1].y,a[n/2+1].x};
    }else{
        rep(i,1,n/2)a[i]=(node){i,n-i+1};
        rep(i,1,n/2-1)Wri(i,i+1);
        if(n/2>2)Wri(n/2,1);
    }
    printf("%d\n",num);
    rep(i,1,num)printf("%d %d\n",ans[i].x,ans[i].y);
    return 0;
}

C - Three Circuits

分类讨论：

如果存在点的度数为奇数，那么不存在欧拉回路，输出No
如果存在大于$4$的度数的点，那么一定存在至少三条欧拉回路，输出Yes
如果存在不小于三个度数恰好等于$4$的点，那么输出Yes
如果存在小于$2$个度数等于$4$的点，那么输出No
如果恰好存在$2$个度数等于$4$的点，那么需要详细进行判断。将两点缩点后，如果两点之间只有$2$条路径，那么输出Yes，否则为No，图片可以参见官方题解文档

Code

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(i,x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int maxn=2e5+6;
struct edge{int to,next;}e[maxn<<1];
int now1=-1,now2=-1,tot=0,num=0,n,m,d[maxn],last[maxn],cnt=0;
void insert(int u,int v){e[++cnt]=(edge){v,last[u]};last[u]=cnt;}
void dfs(int x,int fr){
    reg(i,x){
        if(e[i].to==fr)continue;
        if(d[e[i].to]==2)dfs(e[i].to,x);
        else if(e[i].to==now1)tot+=2;
        else if(e[i].to==now2)tot+=1;
    }
}
int main(){
    n=read(),m=read();
    rep(i,1,m){
        int u=read(),v=read();
        d[u]++,d[v]++;
        insert(u,v);insert(v,u);
    }
    rep(i,1,n)if(d[i]&1){puts("No");return 0;}
    rep(i,1,n)if(d[i]>4){puts("Yes");return 0;}
    rep(i,1,n)if(d[i]==4)num++;
    if(num==0){puts("No");return 0;}
    else if(num>2){puts("Yes");return 0;}
    else if(num==1){puts("No");return 0;}
    else{
        rep(i,1,n)
            if(d[i]==4){
                if(now1==-1)now1=i;else now2=i;
            }
            dfs(now1,-1);
            if(tot>5){puts("Yes");return 0;}
            else{puts("No");return 0;}
    }
    return 0;
}

D - Rotation Sort

将每个点的坐标映射到实数轴上

根据位置进行DP

$ans=\sum A(a_i<b_i) + B(a_i>b_i)$

设状态$f[i][j]$表示处理完$i$，上一个不操作位置为$j$的最小代价

原本一开始想法是区间DP，但貌似出了些问题（不是最优解？？雾）

Code

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(i,x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int maxn=5e3+6;
int n,p[maxn];
ll f[maxn][maxn],A,B;
int main(){
    n=read(),A=read(),B=read();
    rep(i,1,n){int x=read();p[x]=i;}
    mem(f,0x20);
    f[0][0]=0;
    rep(i,1,n+1)rep(j,0,i)
        if(p[i]>p[j]){
            f[i][i]=min(f[i][i],f[i-1][j]);
            f[i][j]=min(f[i][j],f[i-1][j]+B);
        }else f[i][j]=min(f[i][j],f[i-1][j]+A);
    cout<<*min_element(f[n],f[n]+n+1)<<endl;
    return 0;
}

E - Modulo Pairing

将$a_i$升序排列，存在一个分界线$x(0\leq x\leq 2n)$

对于$1<i<x,a[i+1]+a[i]<M$
对于$x\leq i<2n, a[i]+a[i+1]\geq M$
按照$(x-1,x),(x-2,x+1)…$匹配可以得到最优解

可以二分寻找答案

结论题

证明参见官方题解

Code

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(i,x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int maxn=2e5+6;
ll a[maxn],n,m,ans=1e18;
inline bool check(int x){
    ll re=0;
    for(int l=x+1,r=n;l<r;l++,r--){
        if(a[l]+a[r]<m)return 0;
        re=max(re,a[l]+a[r]-m);
    }
    for(int l=1,r=x;l<r;l++,r--)re=max(re,a[l]+a[r]);
    ans=min(ans,re);
    return 1;
}
int main(){
    n=read(),m=read();
    n=n*2;
    rep(i,1,n)a[i]=read();
    sort(a+1,a+1+n);
    int l=0,r=n;
    while(l<r){
        int mid=(l+r)>>1;
        if((n-mid)&1)mid--;
        if(check(mid))r=mid;else l=mid+2;
    }
    check(l);
    cout<<ans<<endl;
    return 0;
}

F题太神仙被咕咕咕了

Usaco2019 feb platinum solution

Thu, 18 Apr 2019 00:00:00 +0000

[USACO19FEB]Cow Dating

题意

给出$N$个接受邀请的概率$p_i$，询问子区间内恰好只有一个奶牛接受邀请的最大概率

分析

区间$[l,r]$的答案为$(1-p_l)\times(1-p_{l+1})\times … \times (1-p_{r}) \times (\frac {p_l} {1-p_l} + \frac {p_{l+1}} {1-p_{l+1}} + … + \frac {p_n} {1-p_n})$

可以用尺取法优化到$O(N)$的时间复杂度

Code

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define mem(x,num) memset(x,num,sizeof x)
#define ll long long
#define reg(i,x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int maxn=1e6+6;
int n;
double p[maxn],ans=0.0,tmp1=1,tmp2;
int main(){
    n=read();
    rep(i,1,n)p[i]=1.0*read()/1e6,ans=max(ans,p[i]);
    //rep(i,1,n)printf("%.4lf\n",p[i]);
    int j=1;
    rep(i,1,n){
        while(j<=n&&tmp1*tmp2<tmp1*(1-p[j])*(tmp2+p[j]/(1-p[j]))){
            tmp1*=(1-p[j]);
            tmp2+=p[j]/(1-p[j]);
            j++;
        }
        ans=max(ans,tmp1*tmp2);
        tmp1/=(1-p[i]);
        tmp2-=p[i]/(1-p[i]);
    }
   // cout<<ans<<endl;
    cout<<(int)(ans*1e6)<<endl;
    return 0;
}

[USACO19FEB]Moorio Kart

题意

给出若干棵树，选择部分节点连接成环，使得环长度不小于$Y$得方案数

分析

考虑利用容斥的思想，所有的路径减去不合法的路径的长度

所有路径的长度较为容易计算，只需要计算每一条边被统计的次数

可以先暴力dfs统计出每个树内部的路径

$f[i][0/1]$表示当前路径和为$i$的方案数/方案权值之和

$g[i][0/1]$表示当前这棵树内部的长度为$i$的方案数/方案权值之和

$f[i+j][0]=f[i][0]\times g[j][0]$

$f[i+j][1]=f[i][0]\times g[j][1] + f[i][1]\times g[j][0]$

时间复杂度$O(N\times Y^{1.5})$

Code

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define mem(x,num) memset(x,num,sizeof x)
#define ll long long
#define reg(i,x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int maxn=3e3+6;
const ll mod=1e9+7;
struct edge{int to,next,w;}e[maxn<<1];
int last[maxn],fa[maxn],bel[maxn],cnt=0,tot=0,n,m,now,X,Y;
ll sum[maxn][maxn],num[maxn][maxn],g[maxn][2],f[maxn][2],ans;
inline int find(int x){return x==fa[x]?fa[x]:fa[x]=find(fa[x]);}
void insert(int u,int v,int w){e[++cnt]=(edge){v,last[u],w};last[u]=cnt;}
void build(int x,int fr,int id){
    bel[x]=id;
    reg(i,x)if(e[i].to!=fr)build(e[i].to,x,id);
}
void dfs(int x,int fr,int l){
    if(fr){sum[bel[x]][min(l,Y)]=(sum[bel[x]][min(l,Y)]+l)%mod;++num[bel[x]][min(l,Y)];}
    reg(i,x)if(e[i].to!=fr)dfs(e[i].to,x,l+e[i].w);
}
int main(){
    n=read(),m=read(),X=read(),Y=read();
    rep(i,1,n)fa[i]=i;
    rep(i,1,m){
        int u=read(),v=read(),w=read();
        insert(u,v,w);insert(v,u,w);
        int r1=find(u),r2=find(v);
        if(r1!=r2)fa[r1]=r2;
    }
    rep(i,1,n)if(find(i)==i)build(i,0,++tot);
    rep(i,1,n)dfs(i,0,0);
    now=min(tot*X,Y);
    f[now][0]=1;f[now][1]=tot*X;
    rep(i,1,tot){
        rep(j,now,Y)g[j][0]=f[j][0],g[j][1]=f[j][1],f[j][0]=f[j][1]=0;
        rep(j,0,Y)
            if(num[i][j])
                rep(k,now,Y)
                    if(g[k][0]){
                        f[min(j+k,Y)][0]=(f[min(j+k,Y)][0]+1ll*g[k][0]*num[i][j])%mod;
                        f[min(j+k,Y)][1]=(f[min(j+k,Y)][1]+1ll*g[k][0]*sum[i][j]+1ll*g[k][1]*num[i][j])%mod;
                    }
    }
    ans=f[Y][1];
    cout<<ans<<endl;
    rep(i,1,tot-1)ans=ans*i%mod;
    cout<<1ll*ans*(mod+1)/2%mod<<endl;
    return 0;
}

[USACO19FEB]Mowing Mischief

题意

给出规模为$T\times T$的平面直接坐标系和$N$个点坐标，其中两个人从$(0,0)$行走至$(T,T)$，行走过程中必须要经过这$N$个点，最大化两个路径形成的相交矩形面积和

分析

首先可以将点排序分层，这样保证后面的点不会对前面的点最优值状态造成影响

$dp[i]=\min { dp[j]+(x_i-x_j)\times (y_i-y_j) } (x_j\leq x_i,y_j\leq y_i)$

将式子展开后

$dp[i]=\min { dp[j]+x_jy_j-x_iy_j-x_jy_i }+x_iy_i (x_j\leq x_i,y_j\leq y_i)$

考虑决策单调性，令在$a$处优于$b$处的转移且$a<b$

$x_i \times (y_b - y_a) + y_i \times (x_b - x_a) < dp_b + x_b \times y_b - dp[a] - x_a \times y_a$

对于等式左边，$x_b-x_a>0,y_b-y_a<0$，而$i$越大$y_i$越小，$x_i$越大，所以左边会越来越小，不等式更容易满足

所以对于两个决策$a$和$b$，一定存在一个分界点，在分界点之前$b$更优，分界点之后$a$更优，即该dp具有决策单调性

因为有对于X和Y的大小限制，所以每个点可以考虑的决策是一个区间

可以直接用线段树维护决策队列来优化

具体而言，线段树的每个节点维护该区间中所有决策的决策队列

Code

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<vector>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define mem(x,num) memset(x,num,sizeof x)
#define ll long long
#define reg(i,x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int maxn=2e5+6;
const ll inf=1e18;
int n,m,tot,f[maxn];
ll dp[maxn];
vector<int> g[maxn];
struct node{
    int x,y;
    inline bool operator < (const node &u)const{return u.x==x?y<u.y:x<u.x;}
    inline bool operator > (const node &u)const{return ((x>=u.x)&&(y>=u.y));}
}a[maxn];
namespace BIT{
    #define lowbit(x) (x&(-x))
    int tree[maxn<<3];
    inline void modifybit(int x,int Val){
        x=max(x,1);
        for(int i=x;i<=m;i+=lowbit(i))tree[i]=max(tree[i],Val);
    }
    inline int querybit(int x){
        int re=0;
        for(int i=x;i;i-=lowbit(i))re=max(re,tree[i]);
        return re;
    }
}
using namespace BIT;
namespace SEG{
    #define ls (x<<1)
    #define rs (x<<1|1)
    #define mid ((l+r)>>1)
    #define MID ((L+R)>>1)
    vector<int>p[maxn<<2];
    vector<int>now,s;
    void build(int x,int l,int r){
        p[x]=vector<int>();
        if(l==r)return;
        build(ls,l,mid);build(rs,mid+1,r);
    }
    void init(int x){
        now=g[x];
        build(1,0,now.size()-1);
    }
    void insert(int x,int l,int r,int k){
        if(a[k].x>=a[now[r]].x&&a[k].y>=a[now[l]].y){
            p[x].push_back(k);
            return;
        }
        if(a[k].x<a[now[l]].x||a[k].y<a[now[r]].y||l==r)return;
        insert(ls,l,mid,k);insert(rs,mid+1,r,k);
    }
    void queryseg(int l,int r,int L,int R){
        if(l>r)return;
        ll ans=inf;
        int x=s[mid],pos=0;
        rep(i,L,R){
            ll re=dp[now[i]]+1ll*(a[x].x-a[now[i]].x)*(a[x].y-a[now[i]].y);
            if(re<ans)ans=re,pos=i;
        }
        dp[x]=min(dp[x],ans);
        queryseg(l,mid-1,pos,R);
        queryseg(mid+1,r,L,pos);
    }
    void work(int x,int l,int r){
        if(!p[x].empty()){
            s=p[x];
            queryseg(0,s.size()-1,l,r);
        }
        if(l==r)return;
        work(ls,l,mid);work(rs,mid+1,r);
    }
}
using namespace SEG;
void solve(int x){
    init(x);
    for(int i=0,sz=g[x+1].size(),ssz=g[x].size();i<sz;i++)insert(1,0,ssz-1,g[x+1][i]);
    work(1,0,g[x].size()-1);
}
int main(){
    n=read(),m=read();
    rep(i,1,n)a[i].x=read(),a[i].y=read();
    a[++n]=(node){0,0};
    a[++n]=(node){m,m};
    sort(a+1,a+1+n);
    rep(i,1,n){
        f[i]=querybit(a[i].y)+1;
        modifybit(a[i].y,f[i]);
        tot=max(tot,f[i]);
        g[f[i]].push_back(i);
    }
    rep(i,1,n)dp[i]=1ll*a[i].x*a[i].y;
    rep(i,1,tot-1)solve(i);
    cout<<dp[n]<<endl;
    return 0;
}

Codeforces global round 2 solution

Sat, 06 Apr 2019 00:00:00 +0000

A. Ilya and a Colorful Walk

题意

给出长度为$n$的序列$C_i$，寻找两个节点$(x,y)$使得$C_x!=C_y$且$y-x+1$（即两点间距离）最大

分析

贪心两头各查找一遍

答案一定包含左右两个端点中的一个

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int maxn=3e5+6;
int n,a[maxn],ans=0;
int main(){
    n=read();
    rep(i,1,n)a[i]=read();
    int p=1,q=n;
    while(p<=q){
        if(a[p]!=a[q]){ans=q-p;break;}
        if(a[p+1]!=a[q]){p++;continue;}
        if(a[q-1]!=a[p]){q--;continue;}
        p++,q--;
    }
    rep(i,1,n-1)if(a[i]!=a[n])ans=max(ans,n-i);
    dep(i,n,2)if(a[i]!=a[1])ans=max(ans,i-1);
    cout<<ans<<endl;
    return 0;
}

B. Alyona and a Narrow Fridge

题意

给出$2\times H$的面积，每一个高度可以放置甲板，同样给出$n$个物体的高度$a_i$，问最多可以在这么大的规模内放下前多少个物体（注意是按给定读入顺序的前$K$个）

分析

二分答案

之后每次重新排序贪心检验

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
#define mid ((L+R)>>1)
const int maxn=1e3+6;
int a[maxn],b[maxn],n;
ll K;
inline bool check(int x){
    ll sum=0;
    rep(i,1,x)b[i]=a[i];
    sort(b+1,b+1+x);
    for(int i=x;i>=1;i-=2)sum+=b[i];
    if(sum>K)return 0;else return 1;
}
int main(){
    n=read(),K=read();
    rep(i,1,n)a[i]=read();
    int L=1,R=n,ans=0;
    while(L<=R){
        if(check(mid))ans=mid,L=mid+1;else R=mid-1;
    }
    cout<<ans<<endl;
    return 0;
}

C. Ramesses and Corner Inversion

题意

给出两个大小为$N\times M$的两个$01$矩阵，每次可以选择一个子矩阵，将子矩阵的四个顶点异或（取反），询问两个矩阵是否可以通过若干次变换相互转化

分析

并不会严谨的数学分析qwq

只是凭感觉YY（猜测）

只需要判断下每行每列的异或和是否相等

如果存在不等的情况，那么无论如何选择子矩阵，因为变换的坐标始终都是同一行（或同一列），所以始终无法改变其每行每列单独的异或和

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int maxn=1e3+6;
int n,m,s1[maxn],s2[maxn],s3[maxn],s4[maxn],a[maxn][maxn],b[maxn][maxn];
int main(){
    n=read(),m=read();
    rep(i,1,n)rep(j,1,m)cin>>a[i][j];
    rep(i,1,n)rep(j,1,m)cin>>b[i][j];
    rep(i,1,n){
        rep(j,1,m)s1[i]=s1[i]^a[i][j],s3[i]=s3[i]^b[i][j];
    }
    rep(j,1,m){
        rep(i,1,n)s2[j]=s2[j]^a[i][j],s4[j]=s4[j]^b[i][j];
    }
    rep(i,1,n)if(s1[i]!=s3[i]){puts("No");return 0;}
    rep(i,1,m)if(s2[i]!=s4[i]){puts("No");return 0;}
    puts("Yes");
    return 0;
}

D. Frets On Fire

题意

给出长度为$n$的序列$S_i$，以及$Q$次询问，每次询问给出$l_k,r_k$两个参数，求出对于所有的$S_i$，在其$S_i+l_k\leq X \leq S_i+r_k$中有多少个不同取值的$X$

分析

先将序列$S$去重，之后求出差分序列

再将差分序列排序后做一遍前缀和

在查询的时候可以二分查询当前的位置，所以可以$O(\log n)$回答

详见代码

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll unsigned long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int maxn=2e5+6;
int n,Q,cnt=0;
ll a[maxn],b[maxn],c[maxn],d[maxn];
int main(){
    n=read();
    rep(i,1,n)a[i]=read();
    sort(a+1,a+1+n);
    a[0]=-1;
    rep(i,1,n)if(a[i]!=a[i-1])b[++cnt]=a[i];
    sort(b+1,b+1+cnt);
    rep(i,1,cnt-1)c[i]=b[i+1]-b[i];
    sort(c+1,c+cnt);
    //rep(i,1,cnt-1)cout<<c[i]<<' ';cout<<endl;
    rep(i,1,cnt-1)d[i]=d[i-1]+c[i];
    Q=read();
    while(Q--){
        ll l=read(),r=read(),len=r-l+1;
        int pos=upper_bound(c+1,c+cnt,len)-c;
        pos--;
        ll ans=(ll)(1ll*len*(ll)(cnt-pos)+1ll*d[pos]);
        cout<<ans<<' ';
    }
    return 0;
}

剩下的待填坑

Codeforces#548 div2 solution

Fri, 05 Apr 2019 00:00:00 +0000

A. Even Substrings

题意

给出数字字符串，求有多少数字子串代表的数字为偶数

分析

判断如果当前数字为偶数，那么答案加上当前的位数

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
int n,ans=0;
int main(){
    n=read();
    rep(i,1,n){
        char ch=getchar();
        if((ch-'0')%2==0)ans+=i;
    }
    cout<<ans<<endl;
    return 0;
}

B. Chocolates

题意

求每个元素不超过给定上限的严格上升序列最大和

分析

贪心：从后往前选择每一位可能的最大值并累和

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int maxn=2e5+6;
int a[maxn],tmp=2e9,n;
ll ans=0;
int main(){
    n=read();
    rep(i,1,n)a[i]=read();
    dep(i,n,1)ans+=min(a[i],max(0,tmp-1)),tmp=min(tmp-1,a[i]);//,cout<<ans<<endl;
    cout<<ans<<endl;
    return 0;
}

C. Edgy Trees

题意

给出一棵边带有属性的树（要么红色要么黑色），统计至少为$K$个节点并包含至少一条黑边的路径数量

分析

容斥原理，可以求出全部为红边的集合

删除黑边求出只包含红边的联通块，对于每个联通块会有$x^K$不合法的路径

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int maxn=3e5+6;
const ll mod=1e9+7;
struct edge{int to,next,w;}e[maxn<<3];
int last[maxn],n,K,tmp=0,cnt=0,b[maxn];
bool vis[maxn];
ll ans;
void insert(int u,int v,int w){e[++cnt]=(edge){v,last[u],w};last[u]=cnt;}
inline ll qpow(ll x,ll y){
    ll re=1;
    x%=mod;
    while(y){
        if(y&1)re=(re*x)%mod;
        y>>=1,x=(x*x)%mod;
    }
    return re;
}
void dfs(int x){
    tmp++;
    vis[x]=1;
    reg(x)
        if(!vis[e[i].to]&&!e[i].w)dfs(e[i].to);
}
int main(){
    n=read(),K=read();
    ans=qpow(n,K);
    rep(i,1,n-1){
        int u=read(),v=read(),w=read();
        insert(u,v,w);insert(v,u,w);
    }
    rep(i,1,n)if(!vis[i]){dfs(i);b[++cnt]=tmp;tmp=0;}
    rep(i,1,cnt)ans=((ans-qpow(b[i],K)+mod)%mod+mod)%mod;
    cout<<ans<<endl;
    return 0;
}

D. Steps to One

题意

每次从$1-m$中随机取出一个数，向集合$s$中添加数字，直至集合中所有的数的$gcd$为$1$，求出问集合大小的期望

分析

集合大小的期望等价于在加最后一个数字之前所有的数字的公因数为不同的值的集合大小的的和

可以使用莫比乌斯函数反演之后求和

$f_i$表示写的序列最大公约数已经等于$i$的情况下写到结束为止的期望长度

$f_i=1+\frac 1 m \sum_{j=1}^n f_{gcd(i,j)}$

移项整理之后发现直接DP的复杂度会是$O(m^2)$

可以统计一下$i$的每个约数对$i$的贡献

先去枚举作为约数的$x$，再去枚举$x$的倍数$n$

即$\sum_{i=1}^m [(n,i)==x]$

反演之后变成$\sum_{d

n} \mu(d) \lfloor \frac m d\rfloor$

于是只需要预处理$n$的约数

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int maxn=2e5+6;
const ll mod=1e9+7;
int m,prime[maxn],cnt=0,mu[maxn],is_prime[maxn]={0};
void Pre(){
    mu[1]=1;
    rep(i,2,m){
        if(!is_prime[i])prime[++cnt]=i,mu[i]=-1;
        rep(j,1,cnt){
            if(prime[j]*i>m)break;
            is_prime[i*prime[j]]=1;
            if(i%prime[j]==0){mu[i*prime[j]]=0;break;}else mu[i*prime[j]]=-mu[i];
        }
    }
}
inline ll qpow(ll x,ll y){
    ll re=1;
    while(y){
        if(y&1)re=(re*x)%mod;
        y>>=1,x=(x*x)%mod;
    }
    return re;
}
int main(){
    m=read();
    Pre();
    ll ans=1;
    rep(i,2,m+1)if(mu[i])ans=(ans-mu[i]*(m/i)*qpow(m-m/i,mod-2)+mod)%mod;
    cout<<ans<<endl;
    return 0;
}

E. Maximize Mex

题意

每个人存在一个权值$p$，每个人又归属于一个集合$c$，$K$次操作每次删除一个人，之后求出每个集合选一个人组成集合的最小非负数的最大值

分析

如果只询问一次且不删点的话那么只需要跑一边二分图

我们可以将删点变成不停加点的过程（倒着跑），每次在上一次的基础上跑一次二分图即可

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int maxn=1e4+6;
int n,m,D,tot,cnt=0,base=5000,link[maxn],last[maxn],val[maxn],group[maxn],le[maxn],ans[maxn],vis[maxn];
bool tmp[maxn];
struct edge{int to,next;}e[maxn<<1];
void insert(int u,int v){e[++cnt]=(edge){v,last[u]};last[u]=cnt;}
inline bool dfs(int x){
    reg(x){
        if(vis[e[i].to]==tot)continue;
        vis[e[i].to]=tot;
        if(link[e[i].to]==-1||dfs(link[e[i].to])){
            link[e[i].to]=x;
            return 1;
        }
    }
    return 0;
}
inline int calc(int x){
    //cout<<x<<"E\n";
    rep(i,x,maxn-1){
        if(link[i]==-1){
            tot++;
            if(!dfs(i))return i;
        }
    }
}
int main(){
    rep(i,0,maxn-1)link[i]=-1;
    n=read(),m=read();
    rep(i,1,n)val[i]=read();
    rep(i,1,n)group[i]=read();
    D=read();
    rep(i,1,D)tmp[le[i]=read()]=1;
    rep(i,1,n)if(!tmp[i])insert(val[i],group[i]+base);
    //puts("R");
    dep(i,D,1){
        ans[i]=calc(ans[i+1]);
        int idx=le[i];
        insert(val[idx],group[idx]+base);
    }
    rep(i,1,D)printf("%d\n",ans[i]);
    return 0;
}

Codeforces#549 div1 solution

Wed, 03 Apr 2019 00:00:00 +0000

A. The Beatles

题意

给一个有$n\times k$个点的环，环上从$1$开始，每$k$个点有一个餐厅，每次可以单向移动$L$个点，现在给出$n$和$k$以及$a,b$（分别表示初始位置离最近的餐厅的距离和第一次移动后离最近的餐厅的距离），询问最少和最多要移动多少次才能够回到初始位置

分析

考虑$L$存在的两种情况

$L=m\times k +b-a$
$L=m\times k -b-a$

其中$m\in [1,n]$

那么移动的次数$ans=\frac {lmc(n\times k , l)} {l} = \frac {n\times k} {gcd(n\times k , l)}$

可以直接暴力枚举

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
ll n,k,l1,l2,a,b,mn=6e18,mx=0;
inline ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
int main(){
    n=read(),k=read(),a=read(),b=read();
    l1=b-a,l2=k-b-a;
    if(l1<=0)l1+=k;
    if(l2<=0)l2+=k;
    rep(i,0,n-1){
        mn=min(mn,min(n*k/gcd(n*k,l1),(n*k/gcd(n*k,l2))));
        mx=max(mx,max(n*k/gcd(n*k,l1),(n*k/gcd(n*k,l2))));        
        l1+=k,l2+=k;
    }
    cout<<mn<<' '<<mx<<endl;
    return 0;
}

B. Lynyrd Skynyrd

题意

给出长度为$m$的序列$p$，和长度为$n$的序列$a$

给出$Q$次询问，每次询问序列$a$的区间$[l_i,r_i]$中是否存在子序列为序列$p$的循环移位

e.g. 循环移位：比如$(2,1,3)$，那么它存在三个等价的循环$(2,1,3)(1,3,2)(3,2,1)$

分析

维护每个元素按照循环排列的下一个元素

之后对每个左端点求出离其最近的右端点位置

但如果暴力查询的话时间复杂度为$O(n\times m)$

可以使用倍增进行优化（因为是连续寻找前驱的操作）

需要倒着循环一遍取后缀最小值

每次询问可以直接$O(1)$判断是否超过最近的右端点即可

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int maxn=2e5+6;
int n,m,Q,p[maxn],a[maxn],fi[maxn],nxt[maxn][26],lst[maxn],minr[maxn];
int main(){
    n=read(),m=read(),Q=read();
    rep(i,1,n)p[i]=read();
    rep(i,1,m)a[i]=read();
    rep(i,1,n-1)fi[p[i]]=p[i+1];fi[p[n]]=p[1];
    rep(i,1,n)lst[i]=m+1;
    nxt[m+1][0]=m+1;
    dep(i,m,1)nxt[i][0]=lst[fi[a[i]]],lst[a[i]]=i;
    rep(j,1,19)rep(i,1,m+1)
        nxt[i][j]=nxt[nxt[i][j-1]][j-1];
    rep(i,1,m){
        int now=n-1,r=i;
        dep(j,19,0)if(now-(1<<j)>=0)now-=(1<<j),r=nxt[r][j];
        minr[i]=r;
    }
    dep(i,m-1,1)minr[i]=min(minr[i],minr[i+1]);
    while(Q--){
        int l=read(),r=read();
        if(r>=minr[l])printf("%d",1);else printf("%d",0);
    }
    return 0;
}

C. U2

题意

给出形如$y=x^2 + bx + c$的二次函数图象（注意没有$a$）

给出$n$个点的坐标，任意两个点可以确定一个二次函数图像

询问在构成的图像中有多少个图像其内部没有顶点

分析

$(x,y)->(x,y-x^2)$

转化之后可以求凸包了

或者可以直接魔改凸包，改成判断是否在抛物线内部即可

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
#define eps 1e-7
const int maxn=2e5+6;
int n,tot=0;
struct P{double x,y;}a[maxn],p[maxn],s[maxn];
inline bool cmp(P a,P b){return a.x==b.x?a.y<b.y:a.x<b.x;}
inline P operator - (P a,P b){P t;t.x=a.x-b.x;t.y=a.y-b.y;return t;}
inline ll operator * (P a,P b){return a.x*b.y-a.y*b.x;}
inline ll dis(P a,P b){return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);}
/*inline bool operator < (P a,P b){
    ll t=(a-p[1])*(b-p[1]);
    if(t==0)return dis(p[1],a)<dis(p[1],b);else return t>0;
}
*/
int main(){
    n=read();
    rep(i,1,n){
        scanf("%lf%lf",&a[i].x,&a[i].y);
        a[i].y=a[i].y-1ll*a[i].x*a[i].x;
    }
    sort(a+1,a+1+n,cmp);
    rep(i,1,n-1)if(fabs(a[i].x-a[i+1].x)>eps)p[++tot]=a[i];
    p[++tot]=a[n];
    int top=0;
    dep(i,tot,1){
        while(top>1&&((s[top]-s[top-1])*(p[i]-s[top-1])<=0))top--;
        s[++top]=p[i];
    }
    cout<<top-1<<endl;
    return 0;
}

皮一下

Wo sind Aufgabe D und E????

Kein Ahnung!

剩下的D和E咕了

Exawizards 2019 solution

Mon, 01 Apr 2019 00:00:00 +0000

A Regular Triangle

题意

确定边长为$A,B,C$的三角形是否为等边三角形

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
ll a,b,c;
int main(){
    a=read(),b=read(),c=read();
    if(a==b&&a==c&&b==c)puts("Yes");else puts("No");
    return 0;
}

B Red or Blue

题意

判断字符串中’R’和’B’出现的数量大小

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
int n,s1=0,s2=0;char ch;
int main(){
    n=read();
    rep(i,1,n){
        cin>>ch;
        if(ch=='B')s1++;else s2++;
    }
    if(s2>s1)puts("Yes");else puts("No");
    return 0;
}

C Snuke the Wizard

题意

给出一排带有属性的格子（全部使用小写字母表示），初始时每个格子上都有一枚硬币

给出$Q$次操作，每次将某种属性的格子上的硬币全部左移或右移一位

移出边界就消失，询问最后剩余的硬币数量

分析

观察后发现移出去的一定是一段前缀和一段后缀，答案具有二分的可行性

因为硬币的相对顺序不变，所以可以直接二分边界

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
#define mid ((l+r)>>1)
const int maxn=2e5+6;
char st[maxn],t[maxn],d[maxn];
int n,Q;
inline int check(int x){
    rep(i,1,Q){
        if(st[x]==t[i])x+=(d[i]=='R')?1:-1;
        if(x>n)return -1;
        if(x<1)return 1;
    }
    return 0;
}
int main(){
    n=read(),Q=read();
    scanf("%s",st+1);
    rep(i,1,Q)cin>>t[i]>>d[i];
    int l=1,r=n,la=0,ra=n+1;
    while(l<=r)if(check(mid)==1)la=mid,l=mid+1;else r=mid-1;
    l=1,r=n;
    while(l<=r)if(check(mid)==-1)ra=mid,r=mid-1;else l=mid+1;
    cout<<ra-la-1<<endl;
    return 0;
}

D Modulo Operations

题意

给出一个长度为$n$的数列和数字$X$，对于数列的每一种排列，其权值$X$依次对排列中的数取模，求出$n!$种情况最后剩下的数的权值和

分析

先要知道一个结论：如果大的数排在小的数字后面，那么大的数字对答案无影响

可以将数列从大到小排序

设$f[i][j]$表示做了$i$次操作，剩余数为$j$的方案数

转移要分为两种情况

选择：$f[i][j\mod a[i]]=f[i][j\mod a[i]]+f[i-1][j]$
不选：$f[i][j]=f[i-1][j]\times (n-i)$

不选的话即可放在后面$n-i$中的任意一个位置

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define rep(i,a,b) for(register int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int maxn=2e2+6,maxX=1e5+6;
const ll mod=1e9+7;
int n,X;
ll f[maxn][maxX],a[maxn],ans=0;
inline bool cmp(ll x,ll y){return x>y;}
int main(){
    n=read(),X=read();
    rep(i,1,n)a[i]=read();
    sort(a+1,a+1+n,cmp);
    f[0][X]=1;
    rep(i,1,n)
        rep(j,0,X){
            f[i][j%a[i]]=((f[i][j%a[i]]+f[i-1][j])%mod+mod)%mod;
            f[i][j]=((f[i][j]+1ll*f[i-1][j]*(n-i))%mod+mod)%mod;
        }
    rep(i,0,X)ans=((ans+1ll*f[n][i]*i%mod)+mod)%mod;
    cout<<ans<<endl;
    return 0;
}

E Black or White

题意

存在一些黑球和白球，两种球都存在的话则各有一半的几率取出，否则一定取出剩下的那种颜色的球

求第$i$次拿到黑球的概率

分析

先不妨假设白球先被拿完，则概率为$g_i=2^{i}{i-1 \choose W-1}$

如果前$i$次把白球拿完的概率为$g_i$，把黑球拿完的概率为$f_i$，那么第$i+1$次取出黑球的概率为$g_i+(1-g_i-f_i)\times \frac 1 2$

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
//******head by yjjr******
const int mod=1e9+7,maxn=2e5+6;
int fac[maxn],inv[maxn],bit[maxn],B,W,sw[maxn],sb[maxn];
inline int C(int n,int k){return 1ll*fac[n]*inv[k]%mod*inv[n-k]%mod;}
inline int qpow(int x,int y){
    int re=1;
    while(y){
        if(y&1)re=(1ll*re*x)%mod;
        x=(1ll*x*x)%mod,y>>=1;
    }
    return re;
}
int main(){
    B=read(),W=read();
    fac[0]=bit[0]=inv[0]=fac[1]=inv[1]=1;
    rep(i,2,B+W)fac[i]=1ll*fac[i-1]*i%mod;
    rep(i,2,B+W)inv[i]=qpow(fac[i],mod-2);
    rep(i,1,B+W)bit[i]=1ll*bit[i-1]*inv[2]%mod;

    rep(i,W,B+W-1)sw[i]=1ll*bit[i]*C(i-1,i-W)%mod;
    rep(i,B,B+W-1)sb[i]=1ll*bit[i]*C(i-1,i-B)%mod;
    
    rep(i,1,B+W)sw[i]=(sw[i]+sw[i-1])%mod,sb[i]=(sb[i]+sb[i-1])%mod;
    rep(i,1,B+W){
        int w=(sw[i-1]+1ll*((mod+1-sw[i-1]-sb[i-1])%mod+mod)%mod*(i==B+W?1:inv[2])%mod)%mod;
        printf("%d\n",w);
    }
    return 0;
}

F题暂时鸽了（咕咕咕）

感觉这场ARC区分度很醚

A&&B简直是CF Div 3????

C一看感觉不可做就自闭放弃了

然后剩下时间都在肝D（感觉难度突然到Div 1???）

而且还在不停地写假算法（很天真地认为自己可以过D）

还有最近比赛的教训：一些表面上很复杂的题目可能比较容易拿分