一共十七划

小说-神无月

Mon, 20 Apr 2026 00:00:22 +0800

第一章只有蝉鸣的废墟

一九九八年，八月。空气稠密得像是一锅煮坏了的胶水。平成十年的夏天似乎致力于把地面上的一切水分都蒸发殆尽。天空呈现出一种病态的惨白，太阳不再是光源，而是一个巨大的、恶意的热辐射核心。在这个连长银都宣告破产、自杀率直线上升的年份里，连蝉的鸣叫声听起来都像是某种绝望的惨叫。井上神社就坐落在这片惨叫声的中心。说是神社，其实更像是一个被时代咀嚼后吐出来的残渣。鸟居上的朱漆早已剥落殆尽，露出底下发灰的木质纹理，像是某种皮肤病；手水舍的水槽里干涸已久，青苔死成了黑色的痂，只有几只不知疲倦的蚊子在腐朽的木柱间盘旋。参道上堆满了无人清扫的落叶和枯枝。拜殿的木板有几处已经腐朽塌陷，踩上去会发出令人牙酸的“咯吱”声。整座神社像是一具被抽干了血液的干尸，在烈日下无声地腐烂。偶尔有路人经过，也只是匆匆瞥一眼，然后加快脚步离开——没有人愿意在一座似乎有什么东西的废墟前停留太久。事实上，井上神社确实有什么东西。只不过，那个东西此刻正被困在更深层的腐烂里。在这片废墟深处的社务所里，一台老旧的三洋电风扇正在发出不堪重负的“嘎吱、嘎吱”声。 “啊——————” 井上美夜子正对着风扇旋转的叶片，张大嘴巴发出毫无意义的长音。声波被扇叶切碎，变成了一种颤抖的电子音，在这个充满了霉味和陈旧榻榻米味道的房间里回荡。她像一滩烂泥一样瘫在地上。身上穿着一套起球严重的芋色运动服，那是她高中时代的遗物，领口松垮得可以直接看到锁骨。一条灰色运动裤随随便便地卷到膝盖以上，露出苍白得有些不健康的小腿。脚边散落着半个被挖得坑坑洼洼的西瓜皮，几本过期的《周刊少年Jump》，以及无数团擦过鼻涕或不知道什么东西的纸巾。虽然是正午，但房间里的窗帘拉得严严实实，只透进几缕昏黄的光线，照亮了空中飞舞的尘埃。对于二十六岁的美夜子来说，这就是她的全世界。没有因为还没有回泡沫而被取消的内定，没有那个指着她的鼻子说“你只是个空壳”的面接官，也没有那个必须要在早高峰挤上电车去扮演白领的东京。这里只有这台连着显像管电视的世嘉土星。美夜子翻了个身，厚如瓶底的黑框眼镜滑到了鼻尖。她抓起手柄，熟练地输入指令，八神庵紫色的火焰映在她呆滞的瞳孔里。屏幕上显示着“ROUND 3”，她的角色只剩下最后一丝血皮，对手是大BOSS。 “干死你……干死你……”她嘟囔着，手指疯狂地敲击着按键，发出噼里啪啦的声响。那种在现实世界中早已磨灭的求生欲，此刻全部倾注在了这几个塑料按钮上。必杀技的蓄力条正在缓慢上涨。她屏住呼吸，瞳孔放大。快了……快了—— “啪、啪。” 两声清脆的拍手声，突兀地穿透了蝉鸣和游戏音效，从外面的拜殿方向传来。美夜子的手指瞬间僵在手柄上。那是参拜礼仪中的二拍手。有人来了。她的心脏猛地收缩了一下，那种熟悉的、令人作呕的心悸感瞬间攫取了全身。是讨债的人吗？还是那个总是想把这块地皮骗走的远房亲戚？或者是那个多管闲事的邻居大婶？美夜子屏住呼吸，连大气都不敢出，像只受惊的蟑螂一样缩在阴影里。她死死盯着那个关得并不严实的门缝，仿佛下一秒就会有一双皮鞋踢开这扇脆弱的门，把她从这个名为家里蹲的安全壳里拖出去暴晒。一分钟过去了。两分钟过去了。外面传来了脚步声，然后逐渐远去。大概只是个路过的迷路者，或者只是随便拜拜就要去别处讨生活的闲人。美夜子长出了一口气，背后的冷汗瞬间被风扇吹得凉飕飕的。 “吓死我了……” 她嘟囔着，重新把注意力放回屏幕上。因为刚才的走神，她的角色已经被打得只剩下一丝血皮——不，是已经被打倒在地，屏幕上出现了“GAME OVER”的字样。 “可恶，这可是我打了三个小时才到的隐藏关卡……” 美夜子咬着牙，手指疯狂地敲击着“继续”按钮。就在她即将按下“CONTINUE”的瞬间滋——！显像管电视发出了一声尖锐的电流音。原本绚丽的格斗画面瞬间崩解，变成了一片令人眼晕的黑白雪花点。紧接着，那个连接着世嘉土星的变压器发出了一声沉闷的爆响，一股焦糊味弥漫开来。 “诶？” 美夜子愣住了。几秒钟后，一声凄厉的惨叫穿透了社务所的屋顶。 “我的存档啊啊啊啊啊啊啊！！” 她抓着头发，整个人跪在地上，对着漆黑一片的电视屏幕发出了灵魂的哀嚎。那是比失业还要痛苦，比被抛弃还要绝望的叫声。那是她这几个月来唯一的成就，唯一的慰藉，就这样化为了乌有。 “完了……全完了……” 美夜子把头埋在膝盖里，眼泪真切地涌了出来。 “吵死了。” 一个稚嫩却带着某种奇怪威严的声音，突然在房间里响起。美夜子抽泣着抬起头。她以为是幻听，或者是电视机里的残留音效。但当她透过满是雾气的眼镜看清眼前的景象时，她的喉咙像是被人掐住了一样，发出了“咯咯”的声音。在那台刚刚报废、还散发着余热的显像管电视机顶上，坐着一个小女孩。看起来大约只有七八岁，皮肤白得近乎透明，在昏暗的房间里散发着一种微弱的幽光。她身上穿着一件极其华丽却破旧不堪的织锦神官服，宽大的袖子像垂死的蝴蝶翅膀一样拖在地上，上面绣着的金线已经氧化发黑。下摆因为太长而胡乱地堆叠着，露出了一双悬在半空中的、赤裸的小脚。最诡异的是，美夜子能透过小女孩的身体，隐约看到后面墙上那张发黄的日历。她是半透明的。那个东西正居高临下地看着美夜子。那种眼神，就像是看着一坨粘在鞋底甩不掉的口香糖，充满了毫不掩饰的嫌弃和轻蔑。小女孩皱起眉头，用那双并不属于这个时代的深邃眼睛环视了一圈满地狼藉的房间——西瓜皮、纸团、旧漫画、还有那个穿着芋色运动服的颓废女人。她伸出一只半透明的小手，掩住鼻子，用清脆却冰冷的童音说道： “余的结界里，为何住着一只猪？” 美夜子张大了嘴巴，眼镜滑落了一半，挂在鼻梁上。在那一刻，比起恐惧，她脑子里首先蹦出来的念头是：啊，太好了。在这该死的一九九八年夏天，在失业和逃避了六个月之后，我终于彻底疯了。她抬起手，用力捏了一下自己的脸颊。疼。很疼。不是梦。 “你……你是什么东西？”美夜子的声音在发抖，但并不是那种要被鬼怪吃掉时的恐惧——而是一种更荒诞的、世界观被砸碎之后的茫然。 “东西？”小女孩的眉毛挑了起来，那张精致的脸上浮现出一种受到冒犯的神情，“余乃建御名方富命杙神，这座井上神社的祭神。汝这无礼之徒，见了神明不行礼也就罢了，竟敢用‘东西’来称呼余？” “神……明？” 美夜子机械地重复了一遍，然后看了看周围。社务所还是那个社务所。霉味还在，风扇还在嘎吱作响，电视还冒着焦糊味的青烟。一切都很正常，除了那个坐在电视机顶上、半透明、自称神明的小女孩。 “汝聋了吗？”小女孩不耐烦地晃了晃悬空的赤脚，“余问汝，为何住在余的结界里？” “这……这是我家的神社。”美夜子下意识地回答。 “汝家的？” 小女孩歪了歪头，似乎在回忆什么。然后她露出一个恍然的表情：“啊……是了。那个叫井上的家族，确实好几代都在这里当神职。这么说来，汝是那个家族的末裔？” “末裔”这个词让美夜子心里刺痛了一下，但她没来得及反驳， “也罢。既然汝是巫女的后人，那就勉强算作余的侍从吧。”小女孩从电视机上飘了下来——是的，飘，她的脚完全没有接触地面——然后双手抱胸，用那种居高临下的眼神看着美夜子，“余饿了。去给余准备供品。” “供……供品？” “对。最好是羊羹。如果没有的话，红豆大福也行。余不挑食——虽然汝看起来也不是什么能供奉得起好东西的穷酸货色。” 美夜子张了张嘴，又闭上。她看了看报废的游戏机，看了看满地狼藉，再看了看眼前这个颐指气使的幼女幽灵。最后，她长长地叹了口气，整个人又瘫回了地上。 “你要吃就吃吧。”她有气无力地说，“反正我已经什么都没有了。要命的话就拿去好了。这破命也不值钱。” 小女孩眯起了眼睛。 “汝……不怕余？” “怕。”美夜子翻了个身，背对着她，“但是比起鬼，我更怕电话铃声。你至少不会让我去面试。” 房间里陷入了一阵诡异的沉默。蝉鸣声重新占据了主导。过了好一会儿，小女孩的声音再次响起，这一次少了几分傲慢，多了几分困惑： “汝……真是个奇怪的人类。” 美夜子没有回答。她把脸埋进散发着霉味的枕头里，闭上眼睛。外面的蝉还在叫。而这个夏天，似乎终于要变得不那么无聊了。

小说-夏夜

Sun, 02 Mar 2025 17:00:22 +0800

那几年夏天的傍晚，总是长得像一辈子也过不完。

她是从阁楼的窗户翻出去的。窗框上的绿漆已经斑驳了，像干燥的皮肤。她把裙子撩起来一点，跨过窗台，脚尖探出去，踩住外面的瓦瓦。瓦是温的，太阳晒了一整天的余温，隔着薄薄的袜子传上来，像谁的手心贴着她的脚掌。

她向前走了几步, 蹲在屋顶的斜坡上，抱住了自己的膝盖。

西边的天正在烧。像一个人在炉火前打瞌睡，脸上的光一寸一寸地暗下去，又一寸一寸地红起来。最底下是橘黄，厚厚的，像抹了一层橘子酱；往上变成橘红，稀薄一些，透出底下的粉；再往上就紫了，是那种洗了很多遍的旧绸缎的颜色，灰扑扑的紫，紫里还藏着一点不肯走的蓝。整片天就那样铺着，瓦也是灰的，远处的楼也是灰的，只有这一片橘黄和橘红，把整个屋顶都染了。她的手背上落了一层光，薄薄的，像涂了蜜。

那个人明天就走了。

这个念头像一粒石子丢进水里，涟漪一圈一圈地荡开。信她看了太多遍，折痕的地方字迹已经模糊了，那个人的名字只剩下一个大概的形状。信上写，南边的树冬天也不落叶，绿的，绿得很满，满得快要溢出来。信上写，听说那边的海很蓝。

海。

她把这个字含在嘴里，悄悄念了一下。海。轻轻的，像叹气。

她没见过海。她见过的最大的水就是运河，灰的，浑的，慢慢地流，像一个永远不着急的人。运河能流到海吗？她盯着那条灰色的带子，它拐了一个弯，被楼房挡住了，又露出来，越来越细，最后消失在橘黄和灰的交界处。她想象河一直流，流过一个又一个傍晚，流过很多她不认识的城市和田野，慢慢变宽，变蓝，变咸，变成那个人正在看的那片海。

风又来了。这一次她闭上眼睛。

她深吸一口气。把所有味道都吸进去。存起来。存在肺的最底下，存在心脏旁边那个她自己都不知道名字的地方。等她老了，等她把这件事忘了很久很久以后，这个味道还会自己跑出来，在某个傍晚，某个起风的时刻，忽然就来了，带着灰色的瓦、橘黄的天、混着水腥气和栀子香的风，带着那个人的名字，带着她十八岁那一年的全部黄昏。

她从口袋里摸出一张纸。

纸被她折了很多次，折成了一个小小的方块，边角都毛了。展开的时候，折痕像地图上的路，一条一条，交错着，把她写过的话切割成碎片。她写了很多遍。第一遍写的是名字，写完了觉得太直白，涂掉了。第二遍写了一整句话，写了又觉得太重，涂得更黑。第三遍写了一个问号，写了又觉得太轻，轻得像什么都没说。最后只剩下角落里的七个字，写得很小，但每个字都用力，纸都被笔尖划破了。

她把纸重新折好。然后爬到屋脊上，骑坐在最高的那条线上。整个小城都在脚下了。

她把那张纸塞进瓦缝里。第三行第五片瓦，从左边数起，太阳晒得最多的那一片。瓦片的边缘有一点青苔，摸上去茸茸的，像什么小动物的背。她把纸塞得很深，藏在温热的瓦片底下，像这个傍晚的一个秘密。

很多年以后，会有人掀开这片瓦吗？会有人发现这张纸吗？那时候她会在哪里？那个人会在哪里？掀开瓦片的那个人，会不会也是一个十八岁的女孩，在某个夏天的傍晚，骑着屋脊，看着西边的天一点一点暗下去？她会读懂这七个字吗？会为这七个字觉得胸口发紧吗？会觉得这个傍晚也变得很长很长，长得像一辈子也过不完吗？

她坐在屋脊上，两只手撑在身后，手心按着温热的瓦。风吹过来，把她的裙摆吹得鼓起来，像一朵倒扣的花，像一只张开的翅膀，像有什么东西要从她身体里飞出去。

她觉得自己快要飞起来了。

但她没有。她只是坐着，坐在灰色和橘黄之间，坐在天空和屋顶之间，坐在这个长得像一辈子的夏天的傍晚里。远处那颗星已经亮了，很淡，像谁在水面上点了一笔白颜料。运河还在流，灰的，慢慢地，往南，往那片她没见过的蓝。

她从口袋里摸出一颗糖，是水果硬糖，橘子味的。剥开玻璃纸的时候，纸在手里窸窣作响，皱成一团亮闪闪的小球。她把糖放进嘴里，硬硬的，在舌头上滚了一圈，甜味慢慢渗出来。

是甜的。是橘子的甜，和天边的橘黄一样甜。

她含着那颗糖，咽了一下口水，喉咙里咕咚一声，像咽下了一小块傍晚。瓦片温着她的掌心，风凉着她的脚踝，嘴里那颗糖越来越小，越来越小，甜味却越来越浓，浓得她眯起了眼睛。

她把玻璃纸展开，对着天看。纸是皱的，但光穿过它的时候，变成了金色。她把那张纸举高一点，再举高一点，举到那片橘黄里去。金色的光斑落在她脸上，落在她的眉毛上、鼻尖上、嘴唇上，像谁在亲她，轻轻地，一个一个地。

然后她把手收回来，把那张皱巴巴的玻璃纸也塞进瓦缝里，和那张纸条放在一起。第三行第五片瓦底下，太阳晒过的地方。纸条上是七个字，玻璃纸上是一个橘子味的傍晚。

她会记住这个味道的。她会的。

风最后来了一次，把她的头发吹到脸上来。发丝贴在嘴角，痒痒的，她把它们拨开，指尖沾上了一点糖的甜。她舔了一下指尖。

甜的。

她笑了一下。然后她站起身，裙子上沾了灰，拍拍，灰飞起来，在橘黄的光里飘了一瞬，就不见了。

她往阁楼走。走到边缘的时候停了一下，回头看了一眼。

第三行第五片瓦。她数了一遍。一、二、三、四、五。

然后她翻过窗台，脚踩在阁楼的地板上。地板是凉的，和瓦片完全不一样的温度。她把窗户关上，把那片橘黄关在外面，把运河的腥气、柴火的烟味、迟开的栀子的香、还有那个橘子味的傍晚，都关在外面。

她靠在窗边，听了一会儿。风在窗外呜呜地响，像在说什么，说了一遍又一遍，她听不清。

但她知道，那片瓦底下有她的七个字，有一颗糖的玻璃纸，有一个十八岁夏天的傍晚。

风会替她记住的。

题解-通过操作使数组长度最小筑-脑筋急转弯,用小数踢掉大数

Sun, 21 Jan 2024 01:51:17 +0800

Problem: 100164. 通过操作使数组长度最小

思路

观察$nums[i]%nums[j]$有如下的可能性
- 如果$nums[i]<nums[j]$,最后只是将数组中的$nums[j]$踢出
- $nums[i]>=nums[j]$则是二者踢出,$nums[i]%nums[j]$进入数组,且显然$nums[i]%nums[j]<nums[j]<=nums[i]$
因为没有限定ij的关系,发现这种操作要么是小数将大数从数组中踢掉,要么是引入一个更小的数,将二者踢掉
最后剩下的长度应该和数组中最小值有关,且这个最小值包括操作中可能产生的
如果没有产生新的最小值,则很容易知道最后剩下的数就是原始数组中最小值的数量,然后将其两两组合,引进0,就能得到答案
如何产生更小值:
- 回顾1,我们将所有数与最小值相模
- 如果余数不为0,就为新的最小值
- 如果余数全为0,说明所有数都是最小值的倍数,则它们之间两两相模的最小值大于等于原始数组的最小值
我们只需要产生一个新的更小值就能把所有其他数都踢掉,此时答案是1

时间复杂度:$O(n)$

Code

class Solution:
    def minimumArrayLength(self, nums: List[int]) -> int:
        m=min(nums)
        for num in nums:
            if num%m!=0:# 可以产生新的最小值
                return 1
        length=nums.count(m)
        return length//2+length%2

题解-需要添加的硬币的最小数量-最大化在缺口处补硬币的作用

Sun, 03 Dec 2023 12:05:00 +0800

Problem: 100153. 需要添加的硬币的最小数量

思路

这题和LeetCode-1798. 你能构造出连续值的最大数目很像,很经典的想法
是子序列所以先排序
先考虑我们手里的硬币能构造出来多少
假设我们手里的硬币足够我们构造出来[0,x),接下来我们又拿到了一个硬币,数值为y,
- 如果我们把y放进之前的所有序列之中,会发现我们能够构造[y,x+y)
- 再加上刚才的区间,我们手里的硬币加y之后能构造的数的范围为$[0,x)\bigcup[y,x+y)$
- 如果y<=x则我们能够构造的数就能达到[0,x+y)
- 如果y>x则会有一段空缺
为了填补这段空缺,我们应该往里面放另一块硬币,假设为z,根据上面的推论,我们很容易得到z会生成的片段为[z,x+z),而且z的取值范围应该为[y-x,x],为了让填补有效,且最大化填补的内容,应该让z=x,因为这样能最大化填补的空缺
- 取最大更有可能单次填补完空缺
而我们遇到的问题只是将y换成了target,所有遇到的大于当前x的也认为是y即可

Code

class Solution:
    def minimumAddedCoins(self, coins: List[int], target: int) -> int:
        coins.sort()
        res=0
        canMake=0 #能生成的范围是[0,canMake]
        i=0
        while i<(len(coins)):
            val=coins[i]
            if val<=canMake+1:
                canMake+=val
                i+=1
            else:
                res+=1 #这里补的硬币就是canMake+1
                canMake+=canMake+1
        while canMake<target:
            res+=1
            canMake+=canMake+1
        return res

题解-求和游戏-数学,以及简单分类证明

Fri, 01 Dec 2023 20:15:11 +0800

Problem: 1927. 求和游戏

初始思路

考虑一些等价:我们先把这个数分为两个部分$left,right$,分别是左右两边数字的和,形式化写为$\displaystyle right=\sum_{i=n/2}^{n}num_i(0<=num_i<=9)$剩下的问号数量分别为$n_{left},n_{right}$
我们要做的实际上是对$left和right$分别操作$n_{left},n_{right}$n次,其中我们允许的操作就是对该数加上0-9的任意一个数
显然操作是对称的,所以我们只考虑有效的操作数,也就是$abs(n_{left}-n_{right})$,而且显然有效的操作数只会存在于一个数身上:如果出现在两个身上就会对称消除
我们可以先除去一些情况:
- 如果剩下的有效操作是奇数,则Alice一定赢,因为她一定不会选择让数相等的操作(只有一个选择),而Alice有10个合法选择
- 然后我们发现操作一定会让数增加,也就是说,如果存在有效操作的是较大的那个数,则一定不可能相等
现在我们只剩下了一种情况:有一个较小的数能够让双方都操作$x$次,如何让较小的数变为较大的数
设两数相差的绝对值为$gap$,每个人能操作$x$次
Alice有两个选择:
- 一个是积极加,在自己的回合里都加9,这样会让较小的数飞快增长,如果两数相差比较小,就能让这个数超过大点的数,从而Bob不能选出来:也就是$9x>gap$,Alice能赢
- 另一个是完全消极,每次都加0,这样会让数缓慢增长,单靠Bob变数增加,如果$gap>9x$,此时Alice也赢
我们惊讶地发现此时出现了9x大于小于gap,Bob都会输,就只剩下了$$9x==gap$$,所幸,我们能发现此时Bob会赢,因为不管此时Alice如何操作,Bob后手都能补齐9

Code

class Solution:
    def sumGame(self, num: str) -> bool:
        n=len(num)
        nums=0
        left=0
        right=0
        for i in range(n//2):
            if num[i]=='?':
                nums+=1
            else:
                left+=ord(num[i])-ord('0')
        for i in range(n//2,n):
            if num[i]=='?':
                nums-=1
            else:
                right+=ord(num[i])-ord('0')
        if nums%2!=0 or (left>right and nums>0) or (left<right and nums<0):
            #最后轮到Alice或者一定不能赢的情况
            return True
        AliceCan=abs(nums)//2
        want=abs(left-right)
        if AliceCan*9!=want:
            return True
        return False

题解-找出叠涂元素-哈希表,两种思路,在途中检查和在最后检查

Fri, 01 Dec 2023 08:51:11 +0800

Problem: 2661. 找出叠涂元素

思路:中途检查

解法

数据量不大,看着可以在每次涂色时候查询是否合法
但是每次都查询显然会超时,我们选择一个更有效的优化
已经说明各个数各不相同,不会出现一个格子被涂两遍的情况
我们用数组来记录每一行和每一列已经被涂的格子数量,就能知道这一行列是否被全涂满

时间复杂度: $O(m*n)$

空间复杂度: $O(m*n)$

Code

class Solution:
    def firstCompleteIndex(self, arr: List[int], mat: List[List[int]]) -> int:
        matMap={} 
        m=len(mat)
        n=len(mat[0])
        row=[0]*m
        col=[0]*n
        for i in range(m):
            for j in range(n):
                matMap[mat[i][j]]=(i,j) 
        for index in range(len(arr)):
            num=arr[index]
            x,y=matMap[num]
            row[x]+=1
            col[y]+=1
            if row[x]==n or col[y]==m:
                return index
            
        return -1

思路:最后查询

解法

我们注意到当我们知道某一行的所有元素的时候,变相知道了这一行会被什么时候涂满,既这一行存在arr中最靠后的那个索引
所以我们的任务变成了寻找最先被涂满的行或者列
对arr进行hash,记录每个元素的具体位置,再遍历行列,在遍历过程中
- 行列取最大值表示让这一行填满最少需要的步数
- res取上述的数的最小值时间复杂度: $O(mn)$ 空间复杂度: $O(mn)$

Code

class Solution {
public:
    int firstCompleteIndex(vector<int>& arr, vector<vector<int>>& mat) {
        int res=arr.size();
        unordered_map<int,int>hash;
        for (int i=0;i<arr.size();i++){
            hash[arr[i]]=i;
        }
        for (int i=0;i<mat.size();i++){
            int tmp=0;
            for (int j=0;j<mat[0].size();j++){
                tmp=max(tmp,hash[mat[i][j]]);
            }
            res=min(res,tmp);
        }
        for (int j=0;j<mat[0].size();j++){
            int tmp=0;
            for (int i=0;i<mat.size();i++){
                tmp=max(tmp,hash[mat[i][j]]);
            }
            res=min(res,tmp);
        }
        
        return res;
    }
};

class Solution:
    def firstCompleteIndex(self, arr: List[int], mat: List[List[int]]) -> int:
        res=len(arr)
        m=len(mat)
        n=len(mat[0])
        arrLocation={}
        for i,a in enumerate(arr):
            arrLocation[a]=i
        for i in range(m):
            nowColNeedSteps=0
            for j in range(n):
                nowColNeedSteps=max(nowColNeedSteps,arrLocation[mat[i][j]])
            res=min(res,nowColNeedSteps)
        for j in range(n):
            nowRowNeedSteps=0
            for i in range(m):
                nowRowNeedSteps=max(nowRowNeedSteps,arrLocation[mat[i][j]])
            res=min(res,nowRowNeedSteps)           
        return res

题解-统计子串中的唯一字符-哈希表+栈，计算贡献

Sun, 26 Nov 2023 16:17:28 +0800

Problem: 828. 统计子串中的唯一字符

思路

注意到一个唯一字符对数个子串生效，也就是在多个子串中唯一字符是固定的那几个，很容易想到贡献法
对于子串起点和终点我们设置成$left,right$,任意字符位置为$a_i$序列,让子串生效的范围是$left-right$这个范围内,存在一个字符a,其序列满足
$$a_{i-1}<left<=a_i<=right<a_{i+1}$$,
同样可以通过枚举起点终点,得知满足这个条件子串的个数为 $(a_i-a_{i-1})*(a_{i+1}-a_{i})$,
为了计算方便我们将-1和n作为每个字符的两端,既$a_{-1}=-1,a_{n+1}=n$
该字母在$a_i$上为答案做的贡献就等于子串的数量

解题方法

使用哈希表存储每个字母的位置序列
为了前后方便我们使用栈来维护具体的字母序列

时间复杂度,O(n)
空间复杂度,O(n)

Code

class Solution:
    def uniqueLetterString(self, s: str) -> int:
        n=len(s) 
        hash=[[n] for _ in range(26)] #最右端点
        for i in range(len(s)-1,-1,-1):
            hash[ord(s[i])-ord('A')].append(i)
            #小的在顶部,大的在底部
        res=0
        for i in range(26):
            pre=-1
            while len(hash[i])>1:
                index=hash[i].pop()
                back=hash[i][-1]
                res+=(index-pre)*(back-index)
                pre=index
        return res

题解-找到 Alice 和 Bob 可以相遇的建筑-单调栈+二分+离线

Sun, 19 Nov 2023 14:19:00 +0800

Problem: 100110. 找到 Alice 和 Bob 可以相遇的建筑

思路

分解一下题目,发现和Alice和Bob二人顺序没关系,为了方便,我们假设Alice所在建筑位置在左边,称为a,bob就会在右边,称为b
假设a,b相等,则所在的位置就是b
若b所在高度大于a,则答案是b
剩下的就是我们要考虑的一般情况:b的高度小于a,

解题方法

我们要做的明确,查b的右侧大于a的第一个建筑
每次都向后查询显然时间复杂度不够,遍历q又是必须的,所以我们想把这个查询压到log级别
显然可以通过维护右侧单调栈+二分的模式
但是为每一个点都配单调栈内存不够
我们发现左边的单调栈一定是右边的转过来的
所以我们只需要维护一个单调栈
在遇到对于要处理的点的查询的时候直接查询就行
也就是我们总体过程是离线查询+单调栈+二分

代码细节

我们先用哈希表记录查询,保证不漏:
先保证a<=b
以b为key,存储想查询的值:a和答案位置i
需要注意的是可能存在多个a的情况,需要用列表而不是一一对应
从后向前遍历,维护单调栈
对于遍历的点,如果在哈希表内,说明其是b
现在维护的单调栈满足需求
二分查到的答案再写回相应的位置

Code

class Solution:    
    def leftmostBuildingQueries(self, heights: List[int], queries: List[List[int]]) -> List[int]:
        n=len(queries)  
        hash={}#记录b对应的a和index
        for i in range(n):
            a=min(queries[i])
            b=max(queries[i])
            if b not in hash:
                hash[b]=[]
            hash[b].append([a,i])
    #记录右边单调递增
    st=[]
    res=[-1]*n
    for i in range(len(heights)-1,-1,-1):
        h=heights[i]
        while st and h&gt;heights[st[-1]]:
            st.pop()
        st.append(i)
        if i in hash:
            b=i
            for a,index in hash[i]:
                if heights[b]&gt;heights[a] or a==b:
                    res[index]=b
                else:
                    l,r=0,len(st)-1
                    while l&lt;=r:
                        mid=(l+r)//2
                        if heights[st[mid]]&gt;heights[a]:
                            l=mid+1
                        else:
                            r=mid-1
                    if (l-1&lt;0):
                        res[index]=-1
                    else:
                        res[index]=st[l-1]
    return res</code></pre>



题解-逃离火灾-两次BFS-在路上不会被烧到,处理边界
Thu, 09 Nov 2023 09:23:43 +0800

Problem: [2258. 逃离火灾](https://leetcode.cn/problems/escape-the-spreading-fire/description/)


思路
– 由题意可知需要计算一条最短路,耗时最短以保证后续火传过来的时候让火传递的时间足够长来接近答案
– 火的蔓延时间用DFS求解,可以求出来火到各个节点的最少用时
– 应该考虑每次刷新一下出发时间来看此次最短路是否被烧掉吗?其实不用
    – 只需要考虑在终点人能否比火早到即可
    – 假如人在路上遇到火,则火到终点的用时一定小于等于人
– 保证了到终点的时候火耗时大于人可以反推出
    1. 人和火相遇的路都能保证有如此长的等待时间
    2. 若人和火不相遇则显然
细节
1. 如果起点起火不可达
2. 对于只有人可达的情况,是等待多久都可以的情况
3. 重点:因为允许人和火同时进安全屋,但是不能要求其他格子里人和火同时到
    1. 考虑将终点旁边的两格当做终点,如果他们到达终点所剩下的时间大于等于1,显然可以在外面等一分钟
解题方法
– 两遍BFS求火和人到各个节点的距离
– 对于起点和终点的几种情况特判
– 查询以终点左边和上边的点是否允许多等一分钟
– 返回答案
Code
class Solution:
    def maximumMinutes(self, grid: List[List[int]]) -> int:
        n=len(grid[0])
        m=len(grid)
        times=[[0x7fffffff]*n for _ in range(m)]
        q=deque()
        directions=[[0,-1],[0,1],[1,0],[-1,0]]
        for i in range(m):
            for j in range(n):
                if grid[i][j]==1:
                    q.append([i,j])
                elif grid[i][j]==2:
                    times[i][j]=-1#不可达
        now=0
        h=set()  
        while q:
            length=len(q)
            for _ in range(length):
                i,j=q.popleft()
                times[i][j]=now
                h.add((i,j))
                for dx,dy in directions:
                    x,y=i+dx,j+dy
                    if 0<=x<m and 0<=y<n and grid[x][y]!=2 and (x,y) not in h:
                        q.append((x,y)) 
            now+=1
        #然后我们求人到各个节点用时
        people=[[0x7fffffff]*n for _ in range(m)]
        q.append((0,0))
        h.clear()
        now=0
        h=set()  
        while q:
            length=len(q)
            for _ in range(length):
                i,j=q.popleft()
                people[i][j]=now
                h.add((i,j))
                for dx,dy in directions:
                    x,y=i+dx,j+dy
                    if 0<=x<m and 0<=y<n and grid[x][y]!=2 and grid[x][y]!=1 and (x,y) not in h:
                        q.append((x,y)) 
            now+=1
        if times[-1][-1]<people[-1][-1] or people[-1][-1]==0x7fffffff:
            return -1 
        if times[0][0]==0:
            return -1
        if times[-1][-1]==0x7fffffff:
            return 1000000000#火不可达,说明人到火这一路都没有火
        maxNeed=times[-1][-1]-people[-1][-1]
        if times[-1][-2]>people[-1][-2]+maxNeed or times[-2][-1]>people[-2][-1]+maxNeed:
            return maxNeed
        return maxNeed-1



题解-每棵子树内缺失的最小基因值
Tue, 07 Nov 2023 15:33:00 +0800

每棵子树内缺失的最小基因值

题目简介
有一棵根节点为 0 的家族树 ，总共包含 n 个节点，节点编号为 0 到 n – 1 。给你一个下标从 0 开始的整数数组 parents ，其中 parents[i] 是节点 i 的父节点。由于节点 0 是 根 ，所以 parents[0] == -1 。
总共有 $10^5$ 个基因值，每个基因值都用 闭区间 $[1, 10^5]$ 中的一个整数表示。给你一个下标从 0 开始的整数数组 nums ，其中 nums[i] 是节点 i 的基因值，且基因值互不相同 。
请你返回一个数组 ans ，长度为 n ，其中 ans[i] 是以节点 i 为根的子树内 缺失 的 最小 基因值。
节点 x 为根的 子树 包含节点 x 和它所有的后代节点。
思路

在概念上与41. 缺失的第一个正数题类似,都是找数,由于本题没有要求O(1)O(1)O(1)的空间复杂度,所以用哈希表是可能的
与数组中缺失的第一个正数类似的是,如果一棵树的节点不包括1,则以该树的任意节点为根的的子树都缺少1,这是最简单的情况
对于子节点有1的才是重要讨论的情况

解题方法

注意到需要处理的只是根节点到基因值为1的这一段的每个节点  

注意到此时讨论的只是一条链
其他的节点的缺失值一定为1


可以用哈希表记录以该节点为根的子树包含的所有基因值,然后再每个节点都遍历一下
上述复杂度很高,再仔细观察节点的哈希表的形式,可以知道父节点的哈希表是所有子节点的合集加上自己的基因数

所以我们只需要自底向上遍历,维护一个哈希表就可以了
注意到父节点缺失的值不可能比子树缺失的还小,所以也需要维护一个基因数


时间复杂度:$O(n)$
空间复杂度:$O(n)$

代码
class Solution:
    def smallestMissingValueSubtree(self, parents: List[int], nums: List[int]) -> List[int]:
        n=len(parents)
        res=[1]*n #默认最有可能缺1
        if 1 not in nums:
            return res
        graph=[[]for _ in range(n)]
        for i in range(1,n):
            graph[parents[i]].append(i)
    visited=set()  
    def dfs(index):
        visited.add(nums[index])
        for child in graph[index]:
            if nums[child] not in visited:
                dfs(child)

    root=nums.index(1) #找分界点
    now=2
    while root&gt;=0: #自底向上递归查找
        dfs(root)
        while now in visited:
            now+=1
        res[root]=now
        root=parents[root]
    return res</code></pre>

其他
这个理论上不能用与41题类似的将数组本身化为哈希表的操作,不然代码的复杂性很高,而且也不好理解


分类
Thu, 02 Nov 2023 11:10:13 +0800



目录
Thu, 02 Nov 2023 10:01:02 +0800



[A=B]攻略-第三章
Tue, 24 Oct 2023 23:02:00 +0800
前言
这个关键字相当于在找到特定的子字符串之后,删去该子字符串,并且将我们指定的新字符串插入到原字符串的开头与结尾
类似于正则表达式的^与$的应用
很像是我们在第二章的操作:将字母压之后换成其他字母往后排以使得压缩持续进行
3-1 去除
相当简单的教程
(start)a=
(end)a=
3-2 旋转
这里只针对前面不是a进行操作,可以保证
(start)b=(end)b
(start)c=(end)c
3-3 A到B 2
思路
开始上难度了,但是其实不难,我们只需要先把所有特定位置的a变成特殊的,然后再处理另一边的特殊的即可
就像是我们之前做过的一样,此时的代码如下
(start)a=x
xa=ax
(end)a=z
az=za
x=b
z=b
优化
我们很容易注意到我们的xa=ax或者之类的操作只是把所有符合要求的串找出来,保证不阻塞生成
于是我们注意到移到另一边的位置显然更好(指行数更小),更新之后如下
代码
(start)a=(end)x
(end)x=(start)b
(end)a=(start)x
(start)x=(end)b
3-5 首尾
通过上一题我们就知道弄到尾部直接判断即可
我们唯一要注意的就是判断在前,不然容易出死循环
ax=(return)true #有任意一个就是真的,能迅速检查到
by=(return)true
cz=(return)true
#以下的操作会1.在有相同的时候把除了最后一个字母之外都换成其他字母插入到后面 2.没有相同的时候所有都插入到后面
(start)a=(end)x
(start)b=(end)y
(start)c=(end)z
=(return)false

3-6 最多 2
思路
与之前的类似,但是我们需要保留所有作比较的字母来保证恢复,然后这里其实就可以
ca=ac
cb=bc
ba=ab
ab=(end)x
cx=(end)y #y代表abc,可随时换成最多的 #剩下ac和bc
#之后我们不用关心y具体是什么,只要二者消耗,剩下的那个做全员回复就行
ac=(end)y
bc=(end)y
#做一个穷举
ax=aa
cy=cc
by=bb
ay=aa
bx=bb

优化
发现ax,ay的行为是相同的,bx,by也是,优化以下
ca=ac
cb=bc
ba=ab
ab=(end)x
cx=(end)y #y代表abc,可随时换成最多的
#acy bcy ay by cy 
ac=(end)y
bc=(end)y
x=y
cy=cc
by=bb
ay=a

3-7回文串
思路
判断是不是消除之后全空即可,如3-5的加强版,我们进行全局替换,然后穷举非空情况,但是注意我们不用考虑剩下来的单个字母的情况,因为那种情况也属于回文串
cz=
by=
ax=
(start)a=(end)x
(start)b=(end)y
(start)c=(end)z
xy=(return)false
xz=(return)false
yx=(return)false
yz=(return)false
zx=(return)false
zy=(return)false
=(return)true
挑战优化
注意到我们六行代码目的都只是为了判断是否有两个字母及以上存在


题解-做菜顺序-排序,贪心,前缀和,一点点证明
Sun, 22 Oct 2023 08:16:17 +0800

Problem: 1402. 做菜顺序


思路

注意到没有要求顺序,先排序
朴素思想是将大的数越往后放越好,但对于负数,虽然也是越大越往后放越好,但其有可能增加答案,也有可能减少答案,需要一些证明

解题方法

注意到对于负数的选取一定是连续而非跳跃的:假设存在$[a_{i-1},a_i,a_{i+1}].a_i<a_{i+1},$数组,三者均小于0,假如一定要取两个元素,(这种假定的含义是我需要后面的正数有足够的倍数,期望前面提供倍数的负数(代价)最小),选取元素$a_{i-1},a_{i+1}$代价大于选取$a_i,a_{i+1}$
推广可知我们会选取所有的正数和部分负数,且负数在排序后的数组中是连续的,并且和正数部分相连
实际上是求一个子数组的这个操作最大能多大,可以枚举每一次从哪选,结束一定是在最大的数结束
然后简化:注意到相关操作实际上是对于之前结果再加上一次已经遍历的数,所以可以将其转化为一遍扫描的方式


时间复杂度, $O(nlogn)$

Code
class Solution:
    def maxSatisfaction(self, satisfaction: List[int]) -> int:
        satisfaction.sort(reverse=True) #方便操作
        res=0
        pre=0
        now=0
        for num in satisfaction:
            pre+=num
            now+=pre
            res=max(now,res)
            if now<0:
                break #之后一定小于0
        return res



题解-最长相邻不相等子序列 II
Sun, 15 Oct 2023 02:42:00 +0800

Problem:最长相邻不相等子序列

题目
给你一个整数 n 和一个下标从 0 开始的字符串数组 words ，和一个下标从 0 开始的数组 groups ，两个数组长度都是 n 。
两个长度相等字符串的 汉明距离 定义为对应位置字符 不同 的数目。
你需要从下标 [0, 1, ..., n - 1] 中选出一个 最长子序列 ，将这个子序列记作长度为 k 的 [i₀, i₁, ..., i_{k - 1}] ，它需要满足以下条件：

相邻 下标对应的 groups 值 不同。即，对于所有满足 0 < j + 1 < k 的 j 都有 groups[i_j] != groups[i_{j + 1}] 。
对于所有 0 < j + 1 < k 的下标 j ，都满足 words[i_j] 和 words[i_{j + 1}] 的长度 相等 ，且两个字符串之间的 汉明距离 为 1 。

请你返回一个字符串数组，它是下标子序列 依次 对应 words 数组中的字符串连接形成的字符串数组。如果有多个答案，返回任意一个。
子序列 指的是从原数组中删掉一些（也可能一个也不删掉）元素，剩余元素不改变相对位置得到的新的数组。
注意：words 中的字符串长度可能 不相等 。


题解-有向图访问计数,一个有向基环树的简单应用
Sat, 14 Oct 2023 08:27:00 +0800
> Problem: 2876. 有向图访问计数
思路
– 注意到这个图一定有环,而且每个点的出度都为1
– 由题意可知从任意节点出发其都能访问到相关的环
– 答案只分为两个情况:
    – 点在环上,此时能访问的点只有环上的点,不可能出环,答案为环的长度
    – 点在环外,除了环本身之外,其能访问本节点到环的几个节点,答案为环的长度加上其到环的距离
– 注意到可能有多个环相互独立存在,但是不可能出现两个环连通,所以几个图之间互相并不干扰
解题方法
1. 由以上思路得到基本想法,遍历解决每一个单独的环即可
2. 选择一个没有访问的节点,开始访问,其一定能进入环
    1. 记录初次访问访问点的深度
    2. 判断是否已经入环的方法就是判断该节点是否已经访问过
3. 对于当前点已经访问过有两种情况:
    1. 当前节点在之前的旧图上就访问过:此时根据访问深度加上之前已经得出点的答案来更新答案数组
    2. 当前节点是在这个新图上访问两次:此时第二次访问深度减去节点访问深度就是环的长度,更新环上节点的答案,环外带上的节点根据访问深度加环的长度更新
4. 持续上述操作直到所有节点都访问过,因为我们每次都将单个有环图的所有节点处理,所以每个节点都已经处理
> 时间复杂度,$O(n)$
> 空间复杂度,$O(n)$
代码
,对于这种问题应该可以补一个快慢指针法,但是此处没有做
class Solution:
    def countVisitedNodes(self, edges: List[int]) -> List[int]:
        n=len(edges)
        res=[-1]*n
        visited=set()
        for i in range(n):
            if i in visited:
                continue
            now=begin=i #记录begin就不用做反图,直接顺序遍历就能找到答案
            tmp=dict()#记录此次遍历的时候访问的点
            index=0
            while now not in visited:
                tmp[now]=index
                visited.add(now)
                index+=1
                now=edges[now]
            # 此时我们访问了的图有三种可能,一条带,一个环,一个有带的环
            # 后两种可能都是如下解法
            if now in tmp:
                #此时tmp[now]长度为点到环的长度
                belt=dict()
                circle=set()
                length=tmp[now]
                now=begin
                while length>0:
                    belt[now]=length
                    length-=1
                    now=edges[now]
                while now not in circle:
                    circle.add(now)
                    now=edges[now]
                r=len(circle)#环的长度
                for u in tmp:
                    res[u]=r if u in circle else r+belt[u]
            # 第一种可能是比较好处理的
            else:
                #说明连接到了之前的有向基环树上,直接与已经访问的点相加即可
                length=index
                baseLength=res[now]
                now=begin
                while length>0:
                    res[now]=baseLength+length
                    now=edges[now]
                    length-=1
    return res</code></pre>



题解-哈希表,用输入流实现C++的split函数
Wed, 11 Oct 2023 06:07:00 +0800

题目:奖励最顶尖的 K 名学生

题目描述
给你两个字符串数组 positive_feedback 和 negative_feedback ，分别包含表示正面的和负面的词汇。不会 有单词同时是正面的和负面的。
一开始，每位学生分数为 0 。每个正面的单词会给学生的分数 加 3 分，每个负面的词会给学生的分数 减  1 分。
给你 n 个学生的评语，用一个下标从 0 开始的字符串数组 report 和一个下标从 0 开始的整数数组 student_id 表示，其中 student_id[i] 表示这名学生的 ID ，这名学生的评语是 report[i] 。每名学生的 ID 互不相同。
给你一个整数 k ，请你返回按照得分 从高到低 最顶尖的 k 名学生。如果有多名学生分数相同，ID 越小排名越前。
思路

题目不难,只需要对比各个词出现次数就可以
对于不同语言来说上面的可能有一定难度
所以写了一版C++的split(是用输入流实现的)

代码
class Solution {
public:
  vector<int> topStudents(vector<string>& positive_feedback, vector<string>& negative_feedback, vector<string>& report, vector<int>& student_id, int k) {
      unordered_map<string,int>score;
      vector<pair<int,int>>list;//直接嵌套vector的时间效率不如pair
      for (auto word:positive_feedback) score[word]=3;
      for (auto word:negative_feedback) score[word]=-1;
      for (int i=0;i<student_id.size();i++){
          string words=report[i];
          int id=student_id[i];
          int s=0;
          string key;
          istringstream is(words);//将字符转成输入流然后操作
          while(getline(is,key,' ')){
              if (score.count(key))
                  //key不存在时int默认为0,但是那样效率不
                  s+=score[key];如判断高
          }
          list.emplace_back(make_pair(id,s));
      }
      sort(list.begin(),list.end(),[&](const pair<int,int>a,const pair<int,int>b){
          return a.second>b.second ||(a.second==b.second&&a.first<b.first);
      });
      vector<int>res;
      for (int i=0;i<k;i++){
          res.emplace_back(list[i].first);
      }
      return res;
}
};



题解-移动机器人-数组计算的三种思考方式方式(动态规划,贡献,前缀和)与相关证明
Tue, 10 Oct 2023 08:04:17 +0800

Problem: 2731. 移动机器人


前述条件

碰撞和1503. 所有蚂蚁掉下来前的最后一刻类似,注意到对于身份没有要求,所以可以直接认为两个机器人碰撞是交换了二者的身份,也可以认为是穿过去了
因此能够得到机器人的最终位置,为了方便计算,我们排序
数据量为$10^5$,暴力求解不现实
以下是三种常用的解决方法,这三种思路最开始的进入方式不同,但是都能得出正确结果

两种对于距离的计算方法
算法的时间复杂度均为$O(n)$
动态规划
思考方式与证明

假设已经计算出来了$a[i]$之前所有的机器人两两之间距离之和为$s$
增加一个元素$a[i]$,观察其和之前的所有机器人之间的距离之和,能够发现

实际上就是与之前的每个元素计算距离
$a[i]$与$a[0],a[1]….,a[i-1]$之间的距离实际上分别是是$a[i-1]$与$a[0]….,a[i-1]$之间的距离加上$a[i]$与$a[i-1]$之间的距离,共$i$个
上述结论可以推导:
设$distance[i]$表示$a[i]$和$a[0],a[1]….,a[i-1]$之间的距离之和,有
$$ distance[i]=i*a[i]+distance[i-1] \distance[0]=0 $$



代码
可以看出来这个公式只与前一个状态有关,因此可以优化空间
class Solution:
    def sumDistance(self, nums: List[int], s: str, d: int) -> int:
        mod=1000000007
        n=len(nums)
        for i,a in enumerate(s):
            nums[i]+=d if s[i]=='R' else -d  
        nums.sort()
        res=0
        distance=0
        for i in range(1,n):
            distance+=i*(nums[i]-nums[i-1]) 
            #这个方法对于只int的话4*(10**9)会超范围
            distance%=mod  
            res+=distance
        return res%mod
贡献距离法
思考方式

对于这种什么什么之和的问题可以考虑计算每个片段对结果的贡献
在这个题目之中片段就是每个元素之间的距离,我们需要计算的就是这段距离在结果中出现了多少次
为了方便理解将每次计算距离视为两点之间的连线,看片段上线的数目就知道这个片段的使用次数
从$a[0]-a[1]$这一的角度来看:从$a[0]$连出去了$n-1$条线,每条线都经过了$a[1]$,所以得出$a[0]-a[1]$段的贡献是$n-1$
从$a[1]-a[2]$的角度来看,$a[1]$连出去的$n-2$也就是$(n-i-1)$条线覆盖了$a[1]-a[2]$

但还不够,注意到$a[0]$发出去的线只有一条落在了$a[1]$上,剩下的线也覆盖了$a[2]$


希望确切地知道此时到底有多少条线覆盖了这段距离

证明

设$f[i]$表示$a[i]$到$a[i+1]$这段距离对结果的贡献次数
同时可知$f[i]$也表示此时距离上面的线段数量
从a[i]发出的所有向右的线都会做贡献,这个次数为$n-i$
发现$a[i]$之前的线段,也就是参与了$f[i-1]$计算的线段,有一部分落在了$a[i]$上,剩下的部分继续参与$f[i]$的计算
可知落在$a[i]$上的线段实际上是a[i]发出的指向左边的线段,其数量为$i$
综上
$f[0]=n-i\f[i]=(f[i-1]-i+n)-i=f[i-1]-2*i+n$
$$\displaystyle res=\sum_{i=0}^{n-2}f[i]*(a[i+1]-a[i])$$

Code
可以看出只与前一个状态有关,进行空间优化
代码为了方便对于$f[i]$计算的是$a[i+1]$到$a[i]$
class Solution:
  def sumDistance(self, nums: List[int], s: str, d: int) -> int:
      mod=1000000007
      n=len(nums)
      for i,a in enumerate(s):
          nums[i]+=d if s[i]=='R' else -d  
      nums.sort()
      pre=0
      res=0
      for i in range(n-1):
          pre=(pre+n-2*i-1)%mod
          res=(res+(nums[i+1]-nums[i])*pre)%mod
      return res
前缀和的形式化证明
下面是灵神的证明方式,与上面的证明相比更加数学,如下
$ (a[i]−a[0])+(a[i]−a[1])+⋯+(a[i]−a[i−1])=i⋅a[i]−(a[0]+a[1]+⋯+a[i−1])\$ $(a[0]+a[1]+⋯+a[i−1])$可根据前缀和求
下面是灵神的代码


[A=B]攻略-第二章
Tue, 03 Oct 2023 21:07:34 +0800
前言
我们要好好理解一下a=(return)b干了啥:

找到匹配的字符串a
将整个我们的字符串变成b
中断循环,看结果

换成函数表达就是
if a in s:
    s=b
    return s
之后判题的只能看到你返回的字符串b
2.1 你好世界
这里给出来了一个提示,在我们用空等的时候
=(return)helloworld
2.2 AAA
思路
我们需要看a的数量,也就是说我们不用管b,c,将二者全消除之后剩下的就是a,再看其是否大于等于3个即可
代码
b=
c=
aaa=(return)true
=(return)false 
2.3 恰好三个
思路
不用管到底是哪个字符,我们只需要验证是不是三个字符即可,所以先把所有字符变成一样的,例如c
接下来我们要判断的不是ccc=(return)true,因为字符串cccc同样包含ccc,

我们首先就排除掉大于3个字符的,其一定包含四个及以上的字符串
这时候对只有三个字符的返回true
剩下的也是false

代码
a=c
b=c
cccc=(return)false 
ccc=(return)true  
=(return)false
2.4 余数
思路
这个是return使用的一个示例,所以我们考虑的仍然是只关心字符串长度,不关心内容

将所有都替换成同样的字符
发现求的事余3,我们只需要每次都将三个字符的串放空,剩下的字符串长度就是总长度余3的结果
将长度换成数字

代码
这个思路在后续也有用
a=c
b=c 
ccc=           
cc=(return)2
c=(return)1
=(return)0
2.5 奇数
思路
划分问题
终于开始上难度了,但是这个 思想其实不难理解,我们先做一个简单的想法,我如何判断一长串a是否由奇数组成?

考虑到字符串长度为1<=n<=7,很容易知道0,1,3,5,7为可能的长度
暴力枚举虽好,但是长度有点太大了,我们可以用另一个方法:奇数减去2之后仍然为奇数
所以我们很容易想到aaa=a来清理串,为什么不能是aa=?
因为这样没有办法确认是刚开始就没有a,还是被偶数a消除掉的
此时长度0,1,2,只有2表示原串是偶数

做法
然后我们知道要去做什么了:把三个字符串相同的集中在一起,相当于按顺序再为这三个字符轮流做上述检查操作
所以需要排序,让相同字符待在一起
接下来问题就好解决了
代码
ba=ab
cb=bc
ca=ac
aaa=a
bbb=b
ccc=c
aa=(return)false
bb=(return)false
cc=(return)false
=(return)true
进阶
你肯定要回来看的,如果你看不懂2.6的话
发现了什么?我们将同样的情况循环了3遍,也就是说,在单独讨论的时候a,b,c其实是等价的,有没有什么办法将它们的等价用代码解释出来?
一个很有趣的想法是将b,c转换成等价a,最后判断三段a是否都满足奇数
一点点魔法:设置一个障碍,让所有相邻相同的字母没有障碍,而让不同的字母之间有障碍
考虑如下代码的运作
ba=ab
cb=bc
ca=ac
b=xxax
c=xaxx
这种情况下会发生什么:相邻的b变成了中间隔着3个x的a,不同字母之间隔着2个x
更加显式地能看到假设 bacacc:


[A=B]攻略-第一章
Sun, 24 Sep 2023 19:34:01 +0800
前言
A=B是一个很好的游戏,建议各位去玩,商店链接
题目从简单到困难,有的时候梯度很大,争取慢慢把这系列做出来,主要是带题解的
不是很喜欢魔数写法,所以大概会更新地很慢
最后,这个游戏真的很有意思
1.1 A到B
没什么好说的
a=b
1.2 大写
a=A
b=B
c=C
1.3 去重
思路
显然我们最后要保留的状态是没有连续字母
只需要将重复的几个压成一个就行,不过要注意A=B这个语言的特殊性
代码
aa=a
bb=b
cc=c
1.4 去重 2
思路
同理,这个是把连续的a压没,
这里之所以会有aaa,而不是直接aa=是因为假如只压缩的可能会剩下来:例如aaa会被替换成a
,我们这么做的本质是将多的字母先压成两个,再把这两个消除掉
aaa=aa
aa=
1.5 排序
思路
研究语言的必经之路,排序,注意到我们现在在做的是替换字符串
我们的目的是希望各个字母都在其应该在的位置,但我们不知道数组下标,怎么样能达成这两个条件呢?
我们需要一个只看相邻的排序算法,也就是冒泡算法,实现起来不难,如下
代码
看到了吗,本质就是大的向后挪动,这个在单步运行时候看的更清楚
ba=ab
cb=bc
ca=ac
这个排序在之后会常用到的,当我们只关心字母数量之类的而不关心其位置的时候
1.6 比较
思路
比较a和b的多少,还记得去重怎么做的吗?把两个相同的数摁在一起消除
这个题也一样,我们把两个不同的字母摁在一起消除,剩下的就是多的字母
值得一提的是压字母存在两个情况
代码
ab=
ba=
aa=a
bb=b


题解-英雄的力量
Tue, 01 Aug 2023 06:31:49 +0800

Problem: 2681. 英雄的力量

题目描述
给你一个下标从0开始的整数数组nums，它表示英雄的能力值。如果我们选出一部分英雄，这组英雄的力量定义为：

i₀ ，i₁ ，… i_k 表示这组英雄在数组中的下标。那么这组英雄的力量为 max(nums[i₀],nums[i₁] ... nums[i_k])² * min(nums[i₀],nums[i₁] ... nums[i_k]) 。

请你返回所有可能的非空英雄组的力量之和。由于答案可能非常大，请你将结果对10⁹+ 7取余。
思路

选取与顺序无关先排序
接下来只要枚举所有子序列的最大值的平方和最小值的乘积之和
注意到只和最大值和最小值有关

解题方法

确定了子序列的最大值之后,我们只需要确定子序列里面各个值最小值出现了几次
也就是确定排序后的$nums[i]$必选且为最大值时,我们假设此时在答案中与除自身之外他的平方相乘的所有值之和为$pre_i$,此时有答案$res_i=nums[i]^2*(pre_i+nums[i])$
不去管$pre_i$现在为多少,我们假设现在要选取的是$nums[i+1]$为最大值,则注意到对于子序列

如果不选$ nums[i] $,$ pre_i$也会和$nums[i+1]$相乘
如果选取$nums[i]$,对于所有$nums[i]$不是最小值的情况,$pre_i$也会和$nums[i+1]$相乘,而$nums[i]$是最小值的情况只有一个(也就是选取$i$和$i+1$两个)


根据以上的两个推理,我们能够得出 $$ \displaystyle res_{i+1}=nums[i+1]^2 \cdot (pre_i \cdot 2+nums[i]+nums[i+1]) \\ pre_{i+1}=pre_i\cdot 2+nums[i] $$
$res=\displaystyle\sum^{n}_{i=0} res_i $


时间复杂度$O(nlogn)$
空间复杂度$O(1)$

Code



class Solution:
    def sumOfPower(self, nums: List[int]) -> int:
        mod=1000000007
        nums.sort()
        pre=0
        res=0
        for num in nums:
            res=(res+(pre+num)*(num**2)
            pre=(pre*2+num
        return res



class Solution {
public:
    int sumOfPower(vector<int>& nums) {
        const int mod=1e9+7;
        sort(nums.begin(),nums.end());
        int res=0,pre=0;
        for (long num:nums){
            res=(res+(num*nu
            pre=(pre*2+num
        }
        return res;
    }
};



翻译:Efficient parallel branch-and-bound approaches for exact graph edit distance problem
Sun, 30 Jul 2023 21:04:50 +0800
是一个作业,但是是自己第一次这么看论文,所以发一下
来自链接

摘要
图编辑算法(Graph Edit Distance ,GED)是一种在图匹配领域广泛使用的方法.它通过计算将一个图转化成另一个图的最小编辑成本来衡量两个图的相似性或差异性.这个过程看起来很简单,但是是NP难问题并且非常耗时,因为它的搜索空间是指数级增加的.一个解决这个问题的最优算法是分支限界法(Branch and Bound，B&B),通过对搜索空间进行隐式枚举而不是而不是基于剪枝技术的全部枚举,来减少探索整个搜索空间的实践.然而当处理大型问题实例的时候,B&B算法探索整个搜索空间所需要的时间仍然太长了,它在此时依然是不够有效的.为了解决这个问题,在本文中我们提出了三种基于共享内存的B&B并行方法来利用多核CPU处理器.第一种是一种工作窃取的方法,多个B&B实例并发搜索单个搜索树,比顺序版本最多快24倍.其次是一种基于树的方法,由独立的B&B实例同时搜索搜索树的多个部分,能够提速28倍,最后,由于GED问题的不规则特性,提出了两种负载均衡策略来保证并行进程之间的负载均衡,达到了令人惊叹的300倍,所有的实验都在知名的数据集上进行过了.
1. 介绍
图编辑算法(Graph Edit Distance ,GED)是一种在图匹配领域广泛使用的方法来计算两个图之间的最小距离.GED算法的目的是计算两个图之间的不相似的总和.换句话说,它代表将一个图编辑成另一个图所需要的最优操作集的成本¹.允许的操作包括插入,删除和增加,这三种操作可以运用在顶点或者边上.这个问题由于其NP难特性而被认为是非常具有挑战性的²,这意味着计算两个图之间最小距离的时间复杂度随着顶点数量的增加呈指数级增长.GED的重要性来自于它的多种使用用例.它可以用于精确匹配也可以用于能容忍一定错误的非精确匹配.并且,GED可以用于多种领域³,特别是在与模式识别相关的领域,比如手写识别⁴⁵⁶,个人识别和认证(例如指纹识别)⁷,文档分析⁵⁸⁹,和图数据库搜索¹⁰.它也可以被用于机器学习,最近邻居分类和数据挖掘领域.⁵
为了计算两个图之间的最佳编辑距离,蚊香³经常使用的基于A*¹¹的搜索算法.然而,这种方法需要大量内存资源,这使得其不能被用于处理大型的图.分支限界法(B&B)是一种广为人知的技术,它通过智能枚举搜索空间来解决最优化问题.这个方法用两个组件,分支(branching)和界限(bounding),将搜索空间建模成一棵树.分支是一个递归的过程,它将一个给定问题的搜索空间划分成多个更小的子问题,并对这些子问题用同样的方式处理,知道找到解决方法.在分支过程结束后,界限操作符评估每一个生成的子问题是否可能包含好的解决方案.B&B算法使用多种技术(消除和选择)来避免探索没有最优解可能的子问题(分支)并家扩搜索过程.由于GED问题的复杂性,它对于一般图来说是NP难问题²,B&B算法需要很长的实践去找到最优解,特别是在解决大型图问题的时候.为了客服这个缺点,我们认为并行计算是一个减少这类问题的运行时间的有趣的方法.
在这片论文之中,我们研究了利用单台计算机的计算资源所带来的影响和可能的收益.事实上,现在的的大部分计算机从硬件上来看都是并行的,能够提供可观的计算能力,尽管在大部分情况下都没能被利用.因此.也为了评估使用并行方法可能得到的收益,我们提出了几种B&B算法.这里的目的是评估每一个并行方法在减少执行时间和有效探索整个搜索空间的影响和行为.我们给出的方法可以归类成高级并行化,其中多个B&B算法的实例同时探索搜索空间.
本文提出了两个并行算法,第一种是基于工作窃取策略,用以在不额外增加内存使用的条件下加快对搜索树的顺序搜索.因此,我们用多个B&B实例同时探索同一颗存储在共享内存空间中的搜索树,所有并行的B&B实例都可以对这个搜索树进行读/写操作.在参考数据集上使用16核CPU的实验显示,相对于顺序版本,速度提升24倍.为了更有效地探索这个搜索空间,也为了研究多样化的影响,我们提出了第二个B&B算法.后者用基于树的方法表示,用多个独立的B&B实例并行地探索整个搜索树的多个部分.因此,更新上界(UB),这最终能够改善一定复杂度.这个算法基于主从策略(Master-Worker),主节点将搜索树分成多个B&B实例,也就是工作者(Workers),在这之后,每一个工作者在自己的内存空间之中构建自己独有的搜索树,进程间唯一共享的信息就是更新的上界的值,这在每一次一个更优路径被发现的时候更新.这个算法得到的结果显示多样化探索过程对性能产生了积极的影响,相比于顺序B&B实例,提速了约28倍.然而,因为搜索树中的子问题的负载不均衡,许多工作者很快地结束了工作(空闲),然而其他会需要运行很长的时间.解决GED问题的负载平衡策略的影响在Abu-Aisheh等人的研究¹²，¹³中没有得到很好的研究.因此,我们提出了两种原创的负载均衡策略来避免工作者的共线.我们的第一种负载均衡策略包括将主节点当做负载均衡器,听过改变它的搜索策略来保证子问题的大量可用性.这个避免空闲的想法就是给所有的并行工作者读写权限来让它们在自己的工作池为空的时候从负载均衡器的工作池之中选取一个子问题.第二种保证工作者之间的负载平衡的方法是将前两个并行算法结合起来.这里的想法是允许工作者在本地进行$k$次迭代,接着将它们自己本地工作池整合进一个共享的全局工作池.用参看数据集刨出来的结果显示了将多样性和负载均衡结合起来带来的好的影响,并且,增加负载均衡算法能够将基于树的并行算法提升高达11倍.
本文余下的内容总结如下.在第二节提出了一些基础的有关GED的符号和定义,在第三节中,我们讨论相关的工作.在第四节描述了串行B&B算法和它的组成,在第五节我们详细介绍我们提出的并行B&B算法和负载均衡策略.在第六节报告计算结果,最终,在第七节提出了结论和展望.
2.问题定义
在接下来的部分,我们首先定义了一些基本的概念接下来去正式地定义GED问题
2.1图(Graph)
一个图是一个用于建模对象之间的成对关系的结构.¹⁴,它包含了一组由一组边连接起来顶点,
正式定义中,一个带标签的图可被表示为$G=(V,E,\alpha,\beta)$,在其中

$V={v_1,v_2,….,v_n}$,表示包含n个顶点的集合
$E={e_1,e_2,…,e_m}$.表示包含个边的集合$(E\subseteq V \times V)$
$\alpha$是顶点的标记函数，也就是将每个顶点映射到一个标记的函数，表示为:$\alpha : V \to L_V$
$\beta$是边的标记函数，也就是将每个边映射到一个标记的函数，表示为:$\beta:V\to L_E$. $L_V$和$L_E$被限制为可以由一组整数描述的标签,向量空间$R^n$或者符号标签

在这篇论文之中,我们考虑简单的无向无环标记图.
2.2 GED操作
在GED问题之中,一个将图$g_1$转换成图$g_2$的编辑路径由一组图的编辑操作组成.每一个编辑操作对顶点,边或者顶点和边执行一次操作.在本文之中,我们采用一种以顶点为中心的方法,其变形都是在顶点上进行的,而其中隐含了对边的操作.因此,只有一下三种基本备案及操作是被允许的:插入($insertion$),删除($deletion$)和替换($substitution$)
我们描述一个顶点$v_i \in V_1$来自于图$g_1$,以及领一个顶点$u_j \in V_2$来自于图$g_2$,我们表示为

$v_i\to u_j:$将顶点$v_i$替换为$u_j$
$v_i\to \epsilon:$,顶点$v_i$从$g_1$之中删除
$\epsilon \to u_j:$顶点$u_j$加入到$g_2$之中

2.2.1隐含的边操作
在以顶点为中心的算法之中,对于边的编辑操作是隐含的,事实上,一个边的替换,删除或者增加取决于它的相关顶点的编辑操作⁵.让我们考虑图$g_1$之中的两个顶点$v,v’$,和另外两个顶点$u,u’$在图$g_2$之中.如果我们在顶点$v$和$v’$进行如下的两个编辑操作${v\to u}$和${v’\to u’}$.可以分别区分出三种边的隐含操作:

如果在$g_1$中$v$和$v’$之间存在一个边$e_1=(v,v’)$,$g_2$也存在一个边$e_2=(u,u’)$连接$u$和$u’$,那么$e_1$就被$e_2$替换掉,表示为$e_1 \to e_2$
如果在$g_1$中$v$和$v’$之间存在一个边$e_1=(v,v’)$,而$g_2$之中没有连接$u$和$u’$的边,那么$e_1$就在$g_1$之中删除,表示为$e_1 \to \epsilon$
如果如果在$g_1$中$v$和$v’$之间不存在边而$g_2$存在一个边$e_2=(u,u’)$,那么$e_2$就被加入到了$g_1$之中,表示为$\epsilon \to e_2$

注意当一个顶点从$g_1$之中删除的时候,与它相连的所有边都被自动删除,类似地,吐过一个顶点被插入进$g_1$所有在$g_2$之中预期相连的边会被插入,如果这个边的另一个端点已经存在于$g_1$之中
2.3成本函数
在GED之中,成本函数是一个重要的组成部分.成本函数为每一个对于边或者顶点的操作分配一个值(成本).因此,图编辑的成本分配影响着最优编辑路径.成本函数提供了一个将与对象相似性有关的领域信息融入进来的有效方法.对于一个特定操作$o$的成本$c(o)$实在底层标签字母表的层面定义的,三种编辑操作的成本给出如下

$c(u\to\epsilon)=\theta$
$c(\epsilon\to v)=\theta$
$c(v \to u)=c(u\to v)=\beta$

我们应该注意如果这两个顶点或者边的拥有相同便签的时候,其替换成本为0.
2.4图编辑距离
让$g_1=(V_1,E_1,\alpha_1,\beta_1)$和$g_2=(V_2,E_2,\alpha_2,\beta_2)$为源图和目标图,分别地,$g_1$和$g_2$之间的图编辑距离由$d(g_1,g_2)$表示,代表着两个图之间的差异程度.换句话说,它代表着一组将$g_1$转换成$g_2$的最优编辑集合${e_1,e_2,…,e_k}$(在成本角度上)
最终,$g_1$和$g_2$之间的图编辑距离(GED)定义为
$$\displaystyle (g_1,g_2)=min_{{e_1,e_2,…,e_k}\in\gamma(g_1,g_2)}\sum_{i=1}^k(e_i)$$
其中$\gamma(g_1,g_2)$表示为所有的将$g_1$转化成$g_2$的编辑路径的集合.每一个路径都包含着一组编辑操作$\lambda {e_1,e_2,…,e_k}$,并且$c(e_i)$表示编辑操作$e_i$的成本⁵
2.5举例
我们将源$g_1$和目的图$g_2$表示在在图1之中,我们让删除和插入的操作成本为2,替换的成本为1,那么将图$g_1$编辑成图$g_2$的最优路径可以由操作四个顶点的替换得到,这意味着要替换三条边,并且删除其他的两条,完整编辑路径如下
$$\lambda(g_1,g_2)={(v_1{B}\to u_1{B}}, {(v_2{A}\to u_1{A}}, ((v_2,v_1)\to \epsilon),\ (v_3{A}}\to u_3{B}),((v_3,v_2)\to (u_3,u_2)),\ (v_4{A}\to u_4{A}),((v_4,v_1)\to (u_4,u_1)),\ ((v_4,v_2)\to \epsilon ),((v_4,v_3)\to (u_4,u_3))}$$


小说-永不放弃
Sat, 22 Jul 2023 08:16:17 +0800
    夏夜，海浪一遍遍拍击着沙滩，踩在冰凉的沙滩上，海水暖洋洋的。她走在前面，在沙滩上留下一串早就看不太清的脚印，又在海浪的冲刷之下消失不见。如果你想说什么的话，现在是最好的时机，因为，“在夏夜发生什么事情都不会意外。”，“好吧，那我还是期待奇迹的”，她像以往一样，眼神聚焦在某个无穷远的点，“奇迹不存在，只有事实存在。”，好吧，一如既往的说教，我想，将她的一句话放进了海风之中，只余下了突兀的沉默，而此时的沉默，也充满了腥咸的气息。这尖锐的沉默驱使着我抬起了手，手中的拍立得相机只剩下一张底片了，虽然我并没有检查。取景器对准了她，我想要尽可能地将圆月与她装进一个底片之中，失败了，照片中的她望着照片外的某处，充满了思考与迷离。
    “给我看看”，手中的照片被她一把抢走了，“不错，我的了。”，“真是一个强盗啊”，一反常态，难以忍受的沉默。“好了，继续走下去吧。”，月光照耀下的脸庞，洋溢着的是她特有的神采奕奕，“好了，我们走下去吧”，涌动的海浪提醒着我这并非某个无知觉的梦，我确确实实站在这里，“好”。可是再漫长的路总会有个尽头，就像现在，她停住了，“好，就这里吧。”，我已经猜到是什么了，心脏如同被锈毁的锯子一下下割着，“不要说下去”，月光照耀下的身影竟平添了一分圣洁，“所以，如果我现在，向海中央走”，我只能沉默，“你会在最后的时候，将我拉回来还是推我一把呢？”，我知道答案，我当然会那么做，但我还是沉默。她也不期待什么回答，或许因为早就知道我的答案，所以，她一步步走向了海中，一步步，奔涌的浪潮吞噬了她的小腿。呜鸣着的海洋将她慢慢吞噬。在那之前，我还是做出来抉择，我拉住了她的手，将她一步步拉到了岸上。此时，海浪呼啸依旧，她尽情地大笑了起来，声音四散而去，我也想跟着笑，但我的声音还未来得及发——“在夏夜发生什么事情都不会意外。”
    我又站在那个夏夜的沙滩之中，手中的是仅剩一张底片的拍立得，就像是以往的无数次尝试一样，我又一次回到了这个原点。“好吧，那我还是期待奇迹的”…不知道多少次了，甚至近乎麻木，但是脚下冰冷的海水提醒着我这并非是一场虚无的梦。“所以，你会怎么做呢？是将我拉回来，还是推我一把呢？”我什么都没有说，举起了那台仅剩下一台底片的相机，在取景窗里看着她一点点消失在海洋之中。我再也忍不住，放声痛哭了起来，呜咽的悲鸣被这呼啸着的海浪吞噬。
    当他再次睁眼的时候，是熟悉的天花板，一切都没有改变，那张带着咸味的照片，随意地躺在枕边。


题解-在二叉树中分配硬币-深度优先搜索,自底向上考虑
Fri, 14 Jul 2023 23:46:22 +0800

Problem: 979. 在二叉树中分配硬币


思路

考虑最后计算成本的时候实际上是计算的是每个节点对硬币的操作数
每个节点只需要一个硬币,如何确定多出来的或少的硬币的流向
考虑自底向上,叶子节点只需要一个硬币,这样就能向父节点要硬币或者向父节点送硬币,之后父节点变成了叶子节点(其子节点已完成使命)
设一个值为$Need$表示需要向上移或者向上要的硬币数,根据以上推论我们能够得到如下公式,正数表示需要向上移动,负数表示需要上方向下移动
$$Need_{节点}=Need_{子节点}+val-1$$
每次将一个节点处理完就将Need的绝对值加入到操作数之中

Code
class Solution:
    def distributeCoins(self, root: Optional[TreeNode]) -> int:
        self.res=0
        def dfs(node:TreeNode):
            if node==None:
                return 0
            left=dfs(node.left)
            right=dfs(node.right)
            self.res+=abs(left)+abs(right)
            return right+left+node.val-1
        dfs(root)
        return self.res
class Solution {
public:
    int res=0;
    int dfs(TreeNode* root){
        if (!root) return 0;
        int left=dfs(root->left);
        int right=dfs(root->right);
        res+=abs(left)+abs(right);
        return left+right+root->val-1;
    }
    int distributeCoins(TreeNode* root) {
        dfs(root);
        return res;
    }
};



[思考]关于知识的诅咒
Fri, 30 Jun 2023 17:07:38 +0800
前言
知识的诅咒,简单来说就是当一个人拥有了某个知识之后,就会不知道自己是如何掌握这个知识的,严重一些的就会出现无法理解没有该知识的人的相关想法。
场景
实际上这个事情的场景很多，我们以熟悉的编程为例：BFS，当我们提到某个编程使用BFS方法的时候，我们会忽略其如何实现，因为当你知道的时候，这个编程问题已经结束了，重点无非是一些实现细节，但是如果你希望将这个方法介绍给某个没有学习过BFS的人呢，你首先一定要介绍BFS，不然一切都是徒劳，当然可能有天赋异禀的人能够通过这些不带注释的代码迅速理解方法，不过这种人还是少数，知道运行逻辑和不知道运行逻辑的代码理解起来的差异可能也算一种。
但是具体来说编程其实属于知识的诅咒比较少的，多数时候可能是了解太多算法然后遇到特定问题不知道如何取舍算一种。这个并不好理解，但是在这就解释到这里。
思考
在讨论的时候我们会经常遇到类似的情况，当涉及到某些概念的时候，我们最好确定交谈的双方都对这个概念有着较为一致的理解，不然容易出现问题。比如说一些对于解构的meme图的解构的meme，对于一个不理解的人呢，你要先介绍原meme，比如说是电车难题，在介绍解构，比如说是马桶搋子，再介绍对这个解构的解构，比如说拿着马桶搋子的人绑在铁轨上，这是一个复杂的过程，而这仅仅只是一张图片。
所以在有些时候，当你只问某个东西是什么的时候，这个问题便已经无法回答了。
但是当这个讨论变成教授的时候，一切都变了。
知识的诅咒出现在教学里，这对很多人来说是深有体会的，你看写书的人迅速几笔带过，但是你自己就是无法理解。这是知识构筑的塔，当你看见某处漏了个洞的时候，你其实不知道这个洞有多深。可能从梯度下降算法开始解释最后细致到三角函数的性质上。当然，这就不是我希望讨论的了。当教的一方发现无法教会的时候，我们总有漫长的路来去找这个诅咒这次落在了哪。
拓展
当然，知识的诅咒也可以是被反向利用的，尽管大部分时候并不是那么有趣。
我也一直在致力于消除自己的一些知识的诅咒，在尝试用一些更加寻常的东西来描述这个世界，和我想解释的问题。所以我摸索出来的就是一些方法：尽可能为每一个我在此次交流中提出的新概念做足够的解释，尽可能在声明之后调用，尽可能将自己无知化…当然，这都是后话了
以上就是全部内容


题解-困于环中的机器人-模拟与相关证明
Tue, 11 Apr 2023 21:51:11 +0800

思路

对于机器人,如果走结束后方向仍在北方,且不在原点才会脱离圈,不然就会困在圈里
因此只需要模拟即可

证明

假设我们第一次位移结束之后之后机器人所在的坐标为(x,y)
我们按照此时机器人面向的方向讨论

此时面向北方的:下一次前进路线和上次一致,第二次前进之后是(2x,2y),以此类推因此只要x,y不全为0则不会回到原点
此时面向南方: 考虑转换参考系,以面朝的方向为y正半轴,此时两个参考系实际上是180度旋转的,在新参考系下前进了(x,y),并转换了方向,在之前的参考系下,下一次的前进方向与这一次相反,也就是说下一次会移动(-x,-y)的位移,并且下次移动之后会转向北方:与没有动之前一致,进入循环
面向东方:同理,不过是每次都是翻转了90度的方向则位移路径为 (0,0)->(x,y)->(x+y,y-x)->(x+y-x,y-x-y)->(x+y-x-y,y-x-y+x),又到0,且方向回到了北方
面向西方同理


也相当于一个向量乘同一个旋转矩阵和位移矩阵多次但是方向需要另外特判一下

实现思路

用一组数字记录当前坐标
方向只有四种,且每个方向前进的方式不同,所以我们可以用数组存储每一种前进方式,根据方向增加
用一个单独的数字记录当前面向的方向
按照操作,模拟前进方式
判断

代码
class Solution {
public:
    bool isRobotBounded(string instructions) {
        vector<vector<int>> direction{{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
        int x=0,y=0,now_direction=0;
        for (char choice:instructions){
            switch(choice){
                case 'G':
                    x+=direction[now_direction][0];
                    y+=direction[now_direction][1];
                    break;
                case 'L':
                    now_direction-=1;
                    if (now_direction<0)
                        now_direction+=4;
                    break;
                case 'R':
                    now_direction+=1;
                    now_direction%=4;
                    break;
                default:
                    break;
            }
        } 
        return !((x!=0||y!=0)&&now_direction==0);
    }
};



题解-移位字符串分组-哈希表
Tue, 14 Mar 2023 17:11:00 +0800

Problem: 249. 移位字符串分组


思路

类似于凯撒密码的归类方式,我们将所有能通过轮转得到的字符串放在一起,不难想到可以通过暴力来对每一个字符串匹配
对于字符串仔细观察可以发现每一个可以归类到一起的字符串的本质是相同的,不只是字符串长度,还有与左右字母之间的差值
综上,对于每一类字符串我们只需要将其转化为模板的样子就能判断是否能归类
我们的问题就是如何将字符转成一个标准的模板
考虑字符之间的相对关系,

我们设首位为0,后面的每一位对应的是字符串该位与前一位的差
如果小于0则加26,来保证模式字符串相等



解题方法

对于每一个字符串,计算其相对字符的模板字符串
查询哈希表,如果有则插入到相对的答案组中
没有就新开一个答案组
重复上述操作

复杂度

时间复杂度:


只遍历一次 $O(mn)$,m为字符串长度


空间复杂度:


运用了哈希表 $O(n)$

Code

class Solution {
public:
    vector<vector<string>> groupStrings(vector<string>& strings) {
        vector<vector<string>>res;
        unordered_map<string,int>hash;//模板字符串及其对应的在答案的行数
        for (auto &iter:strings){
            string tmp="0_";
            char a=iter[0];
            int now;
            for (int i=1;i<iter.size();i++){
                now=iter[i]-a;
                if (now<0)//保证模板的一致性
                    now+=26;
                tmp+=to_string(now)+"_";
                a=iter[i];
            }
            if (hash.find(tmp)!=hash.end()){
                res[hash[tmp]].emplace_back(iter);
            }
            else{
                hash[tmp]=res.size();
                res.emplace_back(vector<string>(1,iter));
            }
        }
        return res;
    }
};



小说-星际时代
Thu, 05 Jan 2023 10:06:00 +0800
他就端坐在复杂的仪表盘之前，严肃地操纵着手中的摇杆，面前的参数一个个变化，他也并不在意，因为眼前的大部分仪表他都不知道是什么意思，只需要按照手册进行操作，飞船就能送你到你要去的地方。感谢这个传奇的时代，能让一个对科技一无所知的人也能独立地驾驶整座飞船在太空中遨游，虽然大部分都要归功于完善的自动驾驶和AI。整个飞船很安静，只能听到飞船偶尔发出的咔嚓声。这或许是必然的命题，我们在宇宙中走得足够远，远到我们每个人都不能听到与我们最相邻的人的声音，那宇宙必然是沉默的。他如是想，随手调出舰载AI，问她“距离最近的补给站有多远？”，
机械合成的声音响起，“2光年”
“修改目标，到最近的补给站”
“收到”
简单干脆地陷入了沉默。他看着全息投影中定制的二次元形象，片刻之后“能再多说几句话吗？”
“尚未实装此功能，请期待后续的更新”
她原本不是这样的，他想，她原本是一个活泼可爱的AI来着，也是在他之前无数的星际航行之中唯一可以谈话的对象，他之前有时候会反思，是不是对一个AI寄托了过多的情感，可她的回应却如此真实。好在，这种病态的反思并没有持续多久，因为所有的AI都被紧急删除或屏蔽了这些对话模块。因为有人真的爱上了舰载AI，提交了结婚申请，以及更重要的，提交人是个未成年。在各界的压力下，飞船公司不得不将舰载AI的功能阉割掉了一些。但公司甚至还没有限制孩子们独立驾驶飞船，他随意摆弄着几个装饰的摆件，“这可真够星际时代的”，没有人回话。但他并不怪那个孩子，毕竟像他这样的人在这漫长孤寂的旅途之中都将她当做自己的精神慰藉，何况孩子。
一片胡思乱想之中，“本舰已接近OS-15532航空站”
“按指引操作”
“收到”
在某个停机库之中，他走了出来。入眼的是整体银白色的太空站主体，通道空旷整洁，沿通道处的窗户还能望到太空站蓝黑色的太阳帆。他并不在乎这些，只是快步走进了空间站的服务层。大厅空荡荡的，整体设施看上去已经有些破旧，只有一个引导机器人还在某个应该称之为桌子的装置后面站着，像是这个安静的太空站的主宰。“欢迎光临，客人”，同样是机械生成的声音，不过听上去更有感情，大抵是花钱了吧。他并不在意，将自己的卡片递出“我要用星际通讯设备”。“请稍后”，那个机器人收起卡片，身前的桌子上的某个仪表动了动，接着就将某个平板显示装置递了过来
他熟练地输入一串地址信息，开始了一段对于广义相对论来说漫长的通讯。不消多久，通话就结束了。他将那块板子还给了机器人，它也在简单检查之后将卡片递了回来，“两千，已扣除”。这可真是一个传奇的时代，我们已经将步伐踏出了那个狭小的星系，超光速航行已经对个人飞船来说小事一桩，但是这种超光速通讯却仍要花费大价钱，还需要在专门的地方，他叹口气，慢慢挪向大厅旁的座椅，面对着太空站巨大的玻璃天幕躺了下来。那是耀眼的群星，与地球上的夜空有着根本的不同，却又如此相似，这种违和感时常困扰着他，不过现在大概也没什么了，因为地球望不到星空了。就在他想着的时候，看到了几道闪光，标准的正方体白光在星空某处突然闪耀，发光的立方体旋转着，似乎在高速向空间站靠近，只是下一秒，一切都归于平静，这静谧的夜空似乎从未变过。这种现象不是第一次出现了，但还没有合理的解释，但是他并不在意，星空之中的未知实在是太多了，解决问题就交给专业的人吧。
就在他又要望着陌生的星空睡去的时候，“叮——”，他接起了通讯“你可真晚”
“出了一些状况，而且我不是来了吗”，一个年轻到有些年幼的充满活力的声音在通讯的另一头响起
“好，等我出站”
飞船驶出太空站，远远就望到了另一艘看上去更加老旧的单人飞船，机械声适时响起，“已建立两舰之间通讯”
他先开口了“晚上好，想去哪玩”
“与我来，我最近发现了一个巨神奇的地方”那个年轻的声音回道
两艘飞船一前一后在宇宙中穿梭，只余下两道低光速带。
一路沉默不语。
“你怎么了，沉默可不像你？”那个孩子问道
“没事，你带路就好”
“好”
“你要不要…”
“嘀——”刺耳的雷达声响起
他立刻操作了几下，飞船猛地做了一个大反转，相控阵雷达全部开启照向某处，他瞥见那艘老旧的飞船也做了类似的操作。在一声沉闷的爆鸣声中，他看清了雷达响起的原因：那是两艘装备着许多杂七杂八兵器的无牌照飞船，
“海盗”他说
“让他们看看我们的厉害”老旧的飞船应声向下移动，同时两发电浆炸弹送了出去。
他的飞船则径直向两艘杂牌舰冲去，雷达对准两艘飞船开启最大功率，想要闪瞎敌人，但影响不大，两艘海盗舰迅速后退想要拉开距离。
在这时，四艘飞船突然齐齐停顿了一下。他反应最快，将头盔上的消息一甩而出，火力倾斜不停，两艘海盗舰在短暂的停顿之后想要再拉开距离，可惜已经太晚了。
“刚刚是什么垃圾新闻，还好我反应快”他说
“热烈庆祝我公司绕地第五航空站核心舱升空…”
“好了，不必再说了”
“嗯，那咱们继续走吧”
“走吧，这个公司也是**，头盔是自己产的就这么为所欲为，差点出事”
“没办法，他们是大公司”
两艘飞船再次启动，飞进无边深空之中。
在暗淡的航行中，一个闪烁着明亮七彩光芒的小星体撞进他的视线
“这是什么？”他扫了一眼雷达然后抬头“刚才没看到，甚至连雷达都没有”
“哼哼~所以这里才是我发现的好地方，IRAS-17514”
“什么怪名字，你已经下去探索过了？”
“这是当然，跟着我”
他的飞船紧紧跟着老旧飞船驶向了那个彩色的星体，眼前的光芒越来越亮，甚至面前的老旧飞船也变成了一个模糊的黑点，他驱动飞船继续靠近，光芒吞噬了眼前的一切。
而后，他的眼前一片黑暗，连飞船仪表盘上的光都看不到，飞船引擎的轰鸣声消失了，耳朵被这轰鸣的沉默充满。他听到了呼呼的风声，也慢慢远去，几秒之后，他眼前亮了起来，那是一条弹出来的讯息：“尊敬的用户您好，因您拖欠我司电费共三个月，且在书面通知下达后仍未缴费，我司已对您中止供电”，头盔显示器又暗了下去。
他摘下头盔，环视一圈在窗外无数高楼大厦的灯光下照耀下的自己的破旧的单人间，叹了口气，躺在勉强能容得下自己身躯的纸壳床上闭上了双眼，沉沉睡去。像是那个时代的许多人一样。


小说-焚鱼成灰
Mon, 02 Jan 2023 17:00:22 +0800
暮色四合，寒鸦声渐，一阵冷风吹过，将火光中冒出的热气吹远，又慢慢沉降，我和她围绕着一团明亮的火焰相伴而坐。“这样就可以了”，她将手中的纸张送进那团光亮之中，那里的火焰迅速升腾而起，不消几秒又在一声轻微的爆鸣声中沉降，我看着火中翻飞着的纸屑，“一切就结束了吧”，纸张有序地一点点送进火中，“这只是某个阶段的结束…它们只是到了应该离开的时候了”，“可是这些只有你自己看过”，火光映照着她面无表情的脸庞，“所以就足够了，这些写出来就是给自己看的”，火中升腾而起的不只有光与热，也有灰黑色的碎屑。
“真可惜，就像是卡夫卡一样”，我半开玩笑地说，她看着那团似乎永远也不会熄灭的希望，“很多人都在我们看不到的地方痛苦地做着一些所谓被社会边缘化的东西，我们需要深刻的批判和思考，但是思考的刀不能落在我们的头上”，火继续燃烧，风一刻不停，此时只有沉默，就像是之前的数次一样，写满了字的纸张在火中卷曲湮灭，尚能认清的只言片语凑不出来整齐的脉络。“就像是碌碌无为的天才”，“你说卡夫卡？”，“这盆火。”，劈啪作响的声音将时间不断拉长，沉默被一声沉闷的声音打破，砸进火中的是一个厚重的本子，看起来被使用得十分充分，它将火焰压了下去，我刚想要做什么，“没事的，马上就会起来的。”，如她所说，在黯淡了几秒之后，那个本子弯曲焦黑，升腾起一阵亮眼的光，“可是那个”，“它们已经完成了一切，只会留下刺耳的呼啸。”，就这样，我和她看着那本陪伴了她三年的故事集化成灰白的碎屑，和一阵浓烟，呛鼻，但不至于落泪。手上的重量一点点减少，光亮明灭，将暮色照清又隐去，她模糊的脸庞并没有别的表情，火光在她的眼中跳跃，清晰明亮。“就这样，把它们全扔进去”，我们的手中什么都没有了，只有那一盆刺眼的猛烈燃烧的焰火，“眼睛疼吗”，我摇摇头，“那就再看一眼吧”。失去了维持的火光跃动，隐去了身形，只余下几枚零星的火星，如同萤火虫，在逐渐深沉的夜色之中飞走。终于是一切结束，我们将这一切收拢妥当，如从未发生过什么一样。走在如墨的夜色之中，她说过，这种景色只应沉默。在归途之上，她哼唱着那首不知名的曲调，我们也在其中隐去了身形。
我沾染上了这个坏习惯。在很久之后，在现在，我再也没办法忽视它们带来的聒噪的声音。当那一切变的空白的时候，我想，我大概是懂得了一些。暮色四合，此时只应沉默。


题解-全局倒置和部分倒置-找数学规律
Wed, 16 Nov 2022 21:51:11 +0800

思路

根据题意可知全局倒置包含局部倒置，对于本题如果有 非局部倒置 的全局倒置，则返回false，不然就返回true
很容易相出用暴力去搜索自己2位之后的数组元素中是否有比自己小的，时间复杂度:$O(n^2)$
倒置是根据的是递增数组出现的，也就是说我们得到的数组实际上是对递增数组进行过几次置换的数组
根据定义可以知道局部倒置的实质就是将相邻的数组元素进行的交换，所以要做的就是与原数组进行比较

位置不变的跳过
位置变化的判断是否和原数组相邻位置的值相等，相等则跳过
不满足上述两个条件的就是全局置换，返回false



代码
class Solution {
public:
    bool isIdealPermutation(vector<int>& nums) {
        int n=nums.size()-1;
        int i=0;
        while (i<n){
            if (nums[i]==i)
                i++;
            else if (nums[i]==i+1&&nums[i+1]==i)
                i+=2;
            else
                return false;
        }
        return true;
    }
};



markdown排版效果
Sun, 30 Oct 2022 15:24:50 +0800
来自这里

尝试学习一些markdown语法,以及一些效果,但是换成HTML之后可能就糊掉了,想不到解决方法
基础部分
typora能够实时渲染,所以记得开源代码显示器
标题
这个我不用多说吧
段落
除了这个回车之外
还有这个 
换行或者shift+entet我
我
我
风格
以下代码能够实现换行,大概,放在最后一行

分割线

这样或者

这样
项

无序项

及其连环套


简单吧


有序

同理


项

引用

引用

和交叉引用



很简单



对吧

层数

强调
包括加粗和斜体甚至可以这样
辅助线
删除和下划线
字体
使用 <font> 标签的修改字体
这里是默认字体
这里是黑体
这里是楷体
这里是扩展字体

使用 <font> 标签的修改字号
这里是默认正文字号
1号字 最小
2号字
3号字 默认
4号字
5号字
6号字
7号字 最大
前景色和背景色
使用 <font> 的标签的修改文字前景色
红色
绿色
蓝色
使用 rgb 颜色值
使用十六进制颜色值
使用 style 属性修改文字的背景色
红色
绿色
蓝色
使用 rgb 颜色值
使用十六进制颜色值
更丰富背景样式
I wish you a Merry Christmas
使用图片作背景


关于
Sun, 01 Nov 2020 14:46:52 +0800
代码苦手,审美奇才
安托涅瓦复现不能之后的产物
网站正在建设中,希望能让你有所收获

一共十七划

小说-神无月

第一章 只有蝉鸣的废墟

小说-夏夜

题解-通过操作使数组长度最小筑-脑筋急转弯,用小数踢掉大数

思路

Code

题解-需要添加的硬币的最小数量-最大化在缺口处补硬币的作用

思路

Code

题解-求和游戏-数学,以及简单分类证明

初始思路

Code

题解-找出叠涂元素-哈希表,两种思路,在途中检查和在最后检查

思路:中途检查

解法

Code

思路:最后查询

解法

Code

题解-统计子串中的唯一字符-哈希表+栈，计算贡献

思路

解题方法

Code

题解-找到 Alice 和 Bob 可以相遇的建筑-单调栈+二分+离线

思路

解题方法

代码细节

Code

题解-逃离火灾-两次BFS-在路上不会被烧到,处理边界

思路

细节

解题方法

Code

题解-每棵子树内缺失的最小基因值

题目简介

思路

解题方法

代码

其他

分类

目录

[A=B]攻略-第三章

前言

3-1 去除

3-2 旋转

3-3 A到B 2

思路

优化

代码

3-5 首尾

3-6 最多 2

思路

优化

3-7回文串

思路

挑战优化

题解-做菜顺序-排序,贪心,前缀和,一点点证明

思路

解题方法

Code

题解-最长相邻不相等子序列 II

题目

题解-有向图访问计数,一个有向基环树的简单应用

思路

解题方法

代码

题解-哈希表,用输入流实现C++的split函数

题目描述

思路

代码

题解-移动机器人-数组计算的三种思考方式方式(动态规划,贡献,前缀和)与相关证明

前述条件

两种对于距离的计算方法

动态规划

思考方式与证明

代码

贡献距离法

思考方式

证明

第一章只有蝉鸣的废墟