Serephus

Echoes from the past

2026-09-23T00:00:00Z

只出现一次的数字

2025-10-26T00:00:00Z

Leetcode上有两道这样的题：

Single Number: Given a non-empty array of integers nums, every element appears twice except for one. Find that single one.

Single Number II: Given an integer array nums where every element appears three times except for one, which appears exactly once. Find the single element and return it.

第一道题我很多年前就见过做过，思路其实很简单也很巧妙，就是利用 x ^ x == 0 和 x ^ 0 == x 这两条XOR的性质，将出现两次的数字互相抵消，从而使得最终的结果为只出现一次的数字，相应的代码如下：

pub fn single_number(nums: Vec<i32>) -> i32 {
    nums.into_iter()
        .fold(0, |init, val| init ^ val)
}

相比之下，第二道就难很多了，虽然题目只变了一处，只是把其余数字的出现次数由2次改为了3次，这一下题目的难度就直线上升了。

这里我们暂时不讨论这个问题具体如何解决，而是先把问题推广到更一般的形式

Single Number III: 给一个非空的整数数组，其中有一个元素出现了k(k >= 1)次，其余元素均出现了p(p > 1且k % p != 0)次，请问如何找出其中出现了k次的那个元素。

在回答这个问题之前，我们可以先思考一下为什么第一题可以这样做，比如第一题的情况，实际上只要k为奇数，p为偶数，都可以这样解决。这其实很像在计数，只不过我们只在乎总数为奇数还是偶数，也就是计数的二进制表示最后一位是1还是0，我们可以通过所有这些数字每个位上1的总数来考虑这个问题，那些出现过p次的数，他们的2进制表示里的每个1都肯定出现了p次，而我们要找的数，则是出现了k次（注意 k % p != 0 ），也就是说，如果我们计数的结果中某一位1出现的次数不能被p整除，那么我们要找的数的对应这1位肯定为1，否则为0。另一种等价的处理是我们希望最后计数的结果是 n % p ，当这个位上出现了p次1时，其最后计数正好抵消为0，这样最终我们只需要检查某个位上的计数是否为0，就可以知道这个位应该是0还是1。也就是说，我们希望有一种特殊的p进制数字，其加法没有进位。在第一题的情况里，就是我们需要没有进位的2进制数，而在2进制下没有进位的加法，实际就是XOR。

如果按照这个思路，直觉上来说我们可以怎么做呢？很简单：

pub fn single_number<const P: usize>(nums: Vec<i32>) -> i32 {
    let cnt = nums.into_iter()
        .fold([0; 32], |mut init, val| {
            for i in 0..32 {
                if 1 << i & val != 0 {
                    // 这里我们保留完整的计数，在下面对计数值进行判断
                    init[i] += 1;
                }
            }
            init
        });
    cnt.into_iter()
        .enumerate()
        .fold(0, |init, (idx, cnt)| match cnt % P {
            0 => init,
            _ => init |= 1 << idx,
        })
}

也就是说，我们使用一个 [i32; 32] 数组来为单独每个位计数，凡是出现了p的整数倍的位我们都置为0，其余位置为1，这样我们就轻松解决了这个更一般的问题。

那么我们能不能进一步“简化”这个做法呢？答案是可以的，因为相对来说我们的P是很小的，而我们用一个 i32 来计数是非常浪费的，我们只需要 $𝑛 = ⌈ {log}_{2} 𝑝 ⌉$ 这么多位就够了。也就是说用一个 [i32; n] 来做计数就够了，代价则是我们需要”转置”这个计数数组，也就是说这n个 i32 的同一个位共同构成了这个位的计数器，而我们则需要进一步推导这里计数的“加法规则”。因为所有位的计数都是完全独立的，我们可以只考虑一个位的情况，然后推广到32位即可。

考虑一个1位的整数 i1 ，我们使用一个 [i1; n] 数组来对其进行计数，假设这里p是3，则n=2，我们有如下真值表：

cnt	0	1
[0, 0]	[0, 0]	[0, 1]
[0, 1]	[0, 1]	[1, 0]
[1, 0]	[1, 0]	[0, 0]

设该位数字为 x ，计数为 [c1, c0] ，通过简单的逻辑代数，我们有如下状态转化方程:

c0' = !c0 & !c1 & x | c0 & !c1 & !x
c1' = c0 & !c1 & x | !c0 & c1 & !x

化简得到

c0' = !c1 & (c0 ^ x)
c1' = c0 & x | c1 & !x (这里能化简的原因是我们不在乎[1, 1]的状态转化)

最终 c0 | c1 的结果就是我们的计数器是否为0，推广到32位数字，我们的计数器则是 [i32; n] ，那么我们有如下代码

pub fn single_number(nums: Vec<i32>) -> i32 {
    nums.into_iter()
        .fold([0, 0], |[c1, c0], x|
            [ c0 & x | c1 & !x, (c0 ^ x) & !c1 ]
        )
        .into_iter()
        // 任意位不为0都说明计数不为0
        .fold(0, |init, val| init | val)
}

这样我们就解决了p为3的问题，通过相同的思路，我们可以解决任意p的问题，区别只在于不同p的化简难度不同。

其实自己做这个题的时候卡了很久也做不出来，思维已经陷入怎么构造位运算来抵消3个数字了，看到题解确实有一种醍醐灌顶的感觉。解决这种问题最重要的还是思路，如果能想到对每一位上的数字做计数，其实已经离正确答案不远了。

参考：

Detailed explanation and generalization of the bitwise operation method for single numbers

Concise solution with Ternary logic || Explained

DOTA2录像查找

2024-11-23T00:00:00Z

简介

最近花了大概三周的时间写了一个通过dota2阵容来查录像id的HTTP接口dota2-match-finder，这里简单写篇博客记录一下。由于我不会写前端，所以没有界面，只有一个简单的HTTP接口，当然后端部分算是比较齐全的，如果最终补上前端界面之类的东西，那么效果会类似于这个现有的网页：combo。做这个事情的缘起也是因为这个网页，我之前偶尔会需要这个功能，比如偶尔刷到什么dota2视频，想看看什么段位，这时候用来找录像是很不错的，不过我感觉这个网页速度挺慢的，而且一些早期的录像应该也是找不到（这个问题很难解决）。我对这个事情正好有一些兴趣，失业也有时间就随便写了一下。

原理

首先说一下为什么能做这件事，所有的dota2公开对局，服务器上都会有记录，V社提供了网页API可以查询，用户只需要在steam上有过一些消费就能获取一个key用来请求这些API，但是V社本身并没有直接提供类似的功能接口，所以如果我们要做这个事情，我们首先需要做的就是获取到这些比赛数据。在公开的API里，有一个API可以用来获取最多100盘比赛的比较详细的信息，而且这个API可以指定一个起始编号，返回从这个编号开始的最近的若干场比赛数据。最终这些数据会以json或者xml的格式返回，我们需要做的就是解析这些文本，再将我们感兴趣的数据保存到数据库里方便后续查询。

返回示例如下：

{
  "result": {
    "status": 1,
    "matches": [
      {
        "players": [
          {
            "player_slot": 0,
            "hero_id": 10,
            "item_0": 1,
            ...
          },
          ...
        ],
        "radiant_win": true,
        "start_time": 1730544120,
        "match_id": 8015500293,
        "match_seq_num": 6742154810,
        ...
      },
      ...
    ]
  }
}

这里为了简洁去掉了大部分的字段，在这些字段里，对我们做这个事情来说，所需要关注的字段只有match_id, match_seq_num以及各个玩家的player_slot和hero_id，match_id和match_seq_num都是一场比赛的有序编号，至于他们之间的区别我并不太清楚，一般我们在客户端或者数据网站使用的是match_id，但这个API需要我们提供的是match_seq_num，而player_slot记录了玩家是天辉还是夜魇，hero_id则记录了玩家使用的是什么英雄，通过这些信息我们就能知道一场比赛的比赛编号和阵容，从而实现我们的目的。这一步我们要做的就是解析这些数据并将其存到一个数据库内。

假设我们已经获取到了我们所需的比赛数据，下一步我们就需要考虑，如何保存这些数据，以及如何查询这些数据来达到比较快的查询速度。最简单的方式，就是原样保存这些数据之后，每次查询时依次获取每条比赛记录，判断是否符合特定阵容来进行筛选。从这种最简单粗暴的方式进行优化，我们有两个可能的优化方向，第一个是减少需要查询的数据量，这就要说到一个常用的优化方法：倒排索引。

倒排索引

倒排索引是一种常用于搜索引擎优化的方法，一般搜索引擎需要快速的查询出同时包含用户提供的若干关键字的网页，倒排索引的思路就是建立一个从关键字到网页编号的倒排索引，比如用户查询A和B这两个关键字时，搜索引擎的后端就分别把包含A和包含B的网页编号取出，再进行求交运算，即可得到同时包含A和B的网页编号。这个方法是典型的用空间来换时间，因为除了原本的网页信息之外，还需要保存这个可能规模非常大的索引。而这个方法能提高查询速度的原因之一就是他减少了我们查询时需要读取的数据量，之前我们需要把所有记录全部读取一遍，现在通过这个索引我们就能只读取自己所需的那一小部分了。

具体到我们这里的问题来说，我们希望用户查询时，能够像opendota combos那样，指定双方的阵容（不假定具体的阵营），我们可以分别保存比赛的原始数据，再维护一个(hero_id, side)到match_id的索引。这样用户指定两个阵容时，我们能够通过正反两次查询得到所有满足要求的比赛编号，再具体查询编号对应的比赛数据返回给用户。这里我们需要应对的第一个问题是存储空间的问题，dota2目前为止大概有几十亿场比赛数据，在不考虑原始数据的情况下，以每场比赛10人，比赛编号是一个64位整数算，未压缩的索引需要占用大约 50_0000_0000 * 10 * 8 / 1024 / 1024 / 1024 = 372.5GiB，考虑压缩率为0.2，那么我们也需要74.5GiB的存储空间用来保存这些索引。假设我们只保存我们所需的最小的数据量，一场比赛的比赛id和10个英雄id，我们大概需要83.8GiB，考虑压缩率之后大概为16.7GiB（很理想，实际上大约为65GiB），可以看到索引的空间还超过了原始比赛的空间。

另外一个需要考虑的问题就是求交运算，按照opendota的数据，英雄出场率一般在0.5-26%不等，那么这个比赛编号的集合最小也达到了2500万的规模，这个大小对于求交运算来说显然有点过大了，甚至于要把这么多比赛编号加载到内存里就需要大概0.18GiB内存。所以如果我们要采用倒排索引的方法，而且我们最终想要收集到所有的数据，那么我们需要根据比赛编号的另一个特征进行优化。那就是比赛编号都是有序的，虽然貌似没有明确的地方表示这些比赛编号是完全有序的，但我们完全可以认为至少绝大部分的比赛编号是按照顺序生成的，在这个前提下，我们可以对比赛编号分段处理，比如每100万一个段，而且这样在我们返回时，也可以优先返回最近的比赛。

位运算

另一个我们可以尝试的优化方向则是如何进行筛选，如果我们不做任何优化，那么之前的筛选是一个子集判定问题，即用户提供了一个阵容组合，我们对每一场比赛，都判定这个特定的阵容组合是否是该比赛的阵容的子集。而当碰到类似这样的问题时，我们总是容易想到使用位运算来做一定的优化，这是因为位运算的按位与或者按位或都非常适合用来做集合元素数量有限情况下的子集判定。而通用情况下，我们一般需要使用哈希表来做，相比之下，哈希表的速度就会慢一些。具体到dota2，我们的阵容是一个hero_id的集合，目前dota2的英雄id在1-145之间，0表示未知英雄，1-145之间还有一些数字未使用，但可以看到，所有英雄id都在u8的范围也就是0-255内，即使考虑到将来的更新，我们也能比较自信的认为，有生之年dota2的英雄id也不会超过255，因此我们可以使用1个256位的二进制整数来表示一个阵容的掩码，这样通过对掩码进行按位与或者按位或运算，我们就可以轻松的判定一场比赛是否有特定的英雄组合。当然，这里考虑到我们的需求，我们实际上需要2个256位的二进制整数，分别用于表示天辉和夜魇的英雄组合掩码。

进一步优化？

位运算和倒排索引其实是不太能结合起来的，因为使用倒排索引的时候，子集判定被转化成了集合求交的问题，也就不需要位运算了，但是如果我们只是采用倒排索引用空间换时间的思路，而不实际用倒排索引的思路，我们实际上可以用大概10倍的空间换大概10倍的查询速度。简单来说就是我们构建一个倒排索引，但是相比之前只保存比赛编号的索引，这个索引里我们同时保存比赛编号和掩码，同时我们不将所有用户指定的英雄的索引读取出来，而是在其中选择一个出场率最低的英雄，只在这个英雄对应的索引里查询，查询也不是求交，而是做掩码操作。但这个方法几乎要求10倍的存储空间，而带来的查询速度提升则取决于英雄的出场率，处于4-200倍之间，感觉对存储空间的利用不够，尤其是对于希望减少使用存储空间的我们来说。

实现

最终我们的要做的事情大概分为三步：收集，保存，查询。至于使用的语言，我能够使用的比较熟练的语言有C/C++/Python/Rust，这里我们选择Rust。

收集

收集这一步，网络方面请求HTTP接口有现成的库(reqwest)可以解决，而且Rust这边还能用上比较时髦的异步编程，这也是不错的，虽然我们其实也不算很需要异步。这一步真正工作量比较大的部分是结果的解析，得益于rust优秀的类型系统和宏，以及serde库优秀的设计，实际上解析非常简单，我们只需要定义对应的结构体，就能通过自动推导Serialize和Deserialize这两个trait，直接使用serde_json来进行对应的解析。

收集部分比较麻烦的是V社对API的请求频率限制，目前DOTA2每分钟的比赛场次大概在300到1200盘左右，按每次100盘算，我们需要大概每5-20秒请求一次才能跟上最新数据，同时我们还需要尽可能的收集历史数据。而实际上只需要大概8秒请求1次就会触发V社的Too Many Request响应，虽然这并不是硬性的限制，但是我们实际上能请求的频率也是比较有限的。我们也不太可能做分布式的收集，所以基本上要将之前的历史数据收集齐是没戏了。

对于历史数据，由于API指定的是起始编号，我们采取了从后往前，对历史数据分段进行收集的策略，每段内部我们从前往后进行收集，同时我们记录下已经收集完毕的分段，方便当收集中断之后恢复。

保存

收集部分完成后，需要考虑的就是如何保存的问题，这里包括选择什么数据库，具体保存那些内容，这里稍微提一下，我是在阿里云买了一个99块1年的低端VPS做这个事情，配置大概是2GiB内存，40GiB硬盘，存储空间显然非常有限，我们最好是尽量减少存储空间的使用。因此我们最终选择放弃倒排索引，所有的比赛数据里，我们也只选择存储绝对必要的内容。至于掩码部分，由于直接存储掩码要求差不多2倍的存储空间，所以我们直接保存2个阵容数组，而选择在查询时动态生成掩码。最终在Rust里，我们保存的数据看起来是这样的

pub struct MatchDraft {
  pub match_id: u64,
  pub radiant: [u8; 5],
  pub dire: [u8; 5],
}

将原始数据转换成这里的数据是比较简单的，这里我假定了每盘比赛双方都是5v5，偶尔V社的服务器会返回一些有问题的比赛数据，对于我们来说一般会碰到的问题是双方的阵容不是5v5，而是6v4或者其他情况，比如8042629407，我基本上选择忽略这些极少数的奇怪数据。

数据库方面我最终选择了ClickHouse，因为这个基本上是我接触的比较多的数据库了，而且我对CH的性能和功能也比较满意，当然CH对我的低端VPS来说算是一个很大的负担，不过我暂时还没有找到其他更合适的替代品。

出乎意料的，使用Rust将数据写入CH或者从CH查询数据都相当简单，CH官方的Rust接口设计的相当易于使用，通过自动推导Row/Serialize/Deserialize这三个trait，我们就能很简单的做到插入和查询，同时我们还能做一些比较简单的创建数据库和表的操作，这基本上已经可以满足我们这里所有的需求。

另外值得一提的是为了提升插入性能，我们需要收集一大批数据再一次性插入，这是因为我们使用的是CH的MergeTree引擎，每条插入都会创建一个临时表，然后在后台进行多表合并。如果你用了大量的插入，那么这些后台合并操作会消耗很多系统资源。由于我们每次请求API都能获得最多100场比赛数据，不过我还是默认设置成等收集到1000场比赛数据才进行一次插入。

查询

这部分我们需要提供一个HTTP接口，我选择了axum这个crate，当然这也是因为这个是我稍微接触过的相关crate，这个使用起来也比较愉快，在接到请求时，我通过用户提供的参数来构造一个SQL语句来向CH进行查询，再将返回的数据返回给用户，相当直观。

如果你想尝试一下这个接口，那么这里我给一个简单的示例：

DOTA2里敌法师的英雄id是1，斧王的英雄id是2，假如我们想要查询一些斧王对敌法师的比赛，那么我们可以用curl构造一个这样的HTTP请求。

curl -X POST "http://120.27.145.242:8888/" --header "Content-Type: application/json" --data '{"team1": [1], "team2": [2], "count": 10, "offset": 0}'

这里的ip和端口当然是我服务器的公网ip和服务绑定的端口，count是场次，默认为10，最大为100, offset是分页的参数，默认为0。返回的结果大概是类似这样的：

[{"match_id":8049200000,"radiant":[63,42,2,31,61],"dire":[86,1,114,121,75]},{"match_id":8049196697,"radiant":[121,56,71,2,101],"dire":[51,86,1,15,97]},{"match_id":8049194746,"radiant":[2,8,103,39,63],"dire":[145,45,1,21,131]},{"match_id":8049194081,"radiant":[1,72,104,84,68],"dire":[2,22,88,39,99]},{"match_id":8049191156,"radiant":[75,86,36,1,71],"dire":[89,126,35,2,14]},{"match_id":8049189562,"radiant":[2,104,6,135,33],"dire":[72,43,126,1,37]},{"match_id":8049189309,"radiant":[61,6,67,19,1],"dire":[2,8,91,41,47]},{"match_id":8049188191,"radiant":[123,5,58,1,89],"dire":[2,48,64,45,14]},{"match_id":8049187394,"radiant":[45,135,1,102,74],"dire":[39,6,2,131,27]},{"match_id":8049186263,"radiant":[60,1,10,85,30],"dire":[97,94,2,51,101]}]

由于我并没有保存其他数据，所以这里能获取的只有比赛id和双方阵容，如果你想看到具体数据，或者下载对应的录像，你可以去类似opendota，dotabuf这样的DOTA2数据网站，或者官方客户端。

当然由于这个程序只从11月22号晚上开始收集，并且在DOTA2高峰期时，V社的API限制让我们无法跟上最新数据，一场比赛的数据可能需要大约几分钟甚至几个小时才能进入数据库，所以如果你找之前或者特别新的比赛，你很有可能是找不到的。

总之这就是全部内容了，整个仓库其实目前只有大概900行代码，很多部分也是做的非常粗糙，不过我也没有太多热情去做这个事情了，如果我有很多高性能服务器能让我玩耍，那我可能更有兴趣去优化这个东西，不过目前只能说就这样吧。

使用Github Actions来部署hexo博客

2022-08-02T00:00:00Z

多年前第一次写博客的时候，选择了hexo这个静态博客框架，这么久用下来，平心而论我对hexo并没有什么不满，我只需要一个地方记录自己写的文字，诸如评论、后台之类的东西对我来说都是略多余的。有了这些也不错，但是没有也完全没问题。有评论更方便交流，没有也没啥影响，我的文章也没啥人读。当然hexo本身是可以挂上一个外部的评论服务的，但是我懒，也没需求，就没搞。不像评论，后台实时写文章实时发表这样的功能是不可能实现的，当然这也不是必需的，有这个后台，你可能管理博客更方便，但是没有其实也没啥问题。总之我对hexo本身倒是没啥不满，只不过对npm有点不满，总的来说，我不是很喜欢npm的设计，之前在windows上使用hexo的时候，总会留下一个因为超过路径长度限制而无法删除的node_modules文件夹，网上也经常看到把node_modules和黑洞对比的meme

总之用久了hexo之后，很希望有一个工具能自动帮我生成网页文件，再发布到Github Pages上去。一来省去我自己手动操作，二来我电脑也不需要承担node_modules这种“负担”。这个解决方案其实几年前就有了，那就是CI工具，其中就有Github Actions，Github Actions是Github官方提供的CI工具，这个工具可以响应你的Github仓库的各种事件，来对应的执行一些自动操作。比如当你推送提交到Github上或者别人开pr时，进行自动的编译和测试。

Hexo的博客也可以通过Github Actions来进行自动生成和发布。如我所言，Github Actions早就有了，但是我到现在才搞，一来是因为我懒，不想学，二来是我的需求有一点特殊。

虽然早有人写了满足这个条件的action，但我还是拖到了现在才开始做这件事，这里就权且记录一下。

为了做到这件事情，一般推荐建立两个仓库，一个是Github Page，用于发布公开的网页，一个是私有的文章源文件，包括hexo的项目、配置、主题等等。我个人设置私有的原因主要还是不公开一些草稿，因为我个人经常会把一些之前质量较低的文章移到草稿文件夹来隐藏掉。

执行action的bot在源仓库做自动生成和部署，将网页文件推送至公开仓库，同时将必要的修改提交到源仓库，因此同时需要这两个仓库的读写权限。源仓库的写入权限实际上可以通过GITHUB_TOKEN来解决，这是因为每次运行action的时候，GIthub都会生成一个临时的访问token，这个token就有action运行仓库的写入权限。而公开仓库的写入权限则可以通过多种方式实现，以下仅以我使用的action为例，介绍SSH方式。

我使用的action仓库是 github-actions-hexo ，选择的原因前面说了是这个action可以在生成部署之后更新源仓库。这个action是通过hexo-deployer-git插件来部署的，需要bot运行git命令时有公开仓库的写入权限。其中需要用到一个部署的公钥，你需要将公钥的内容存入公开仓库的部署公钥(仓库Settings/Deploy keys)内且赋予写权限，这样对应的私钥方就可以通过git修改公开仓库了。你可以将对应的私钥保存到源仓库的SECRET里，这样在action bot在源仓库运行时，它就可以通过这个私钥来修改公开仓库。同时SECRET里的条目不会被任何人看到，存入后即使是你自己也看不到，不会有安全问题。这里建议生成一个新的密钥对，专门用于部署。

ssh-keygen -f <filename>

可以在action仓库里看到entrypoint.sh文件内有如下内容

# setup key
mkdir -p /root/.ssh/
echo "${INPUT_DEPLOYKEY}" >/root/.ssh/id_rsa
chmod 600 /root/.ssh/id_rsa
ssh-keyscan -t rsa github.com >>/root/.ssh/known_hosts

git config --global user.name "${INPUT_USERNAME}"
git config --global user.email "${INPUT_EMAIL}"

这就是配置git，确保后续能用hexo-deployer-git插件进行部署，其中的INPUT_DEPLOYKEY变量就是你配置好的私钥内容。由于这个action的提交信息无法修改且里面包含一个typo，所以我fork了这个action并做了修改。

配置好公钥和私钥之后，只需要在源仓库内添加一个yml格式的workflow就能实现自动生成和部署了。

name: Build and Deploy Hexo Posts

on:
  push:
    branches: [ 'main' ]
  workflow_dispatch:

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          submodules: true

      - name: Cache node modules
        uses: actions/cache@v1
        with:
          path: node_modules
          key: ${{runner.OS}}-${{hashFiles('**/package-lock.json')}}
      - uses: serephus/github-actions-hexo@dev
        with:
          deploykey: ${{secrets.HEXO_DEPLOY_PRIVATE_KEY}}
          username: <yourusername>
          email: <youremail>
          if_update_files: true
          github_token: ${{secrets.GITHUB_TOKEN}}
          branch: main

记得把尖括号替换成你对应的内容， secrets.HEXO_DEPLOY_PRIVATE_KEY 就是我配置的私钥变量，Github Action通过 ${{ variable }} 的方式展开变量。

这里是我的配置，如果你的theme是一个submodule, 那么checkout的action里要配置下载子模块。

做好这些之后，就无需手动更新公开仓库了，可以更加专注于文章写作本身。

在处理好这些以后，我也是久违的更新了一下博客的主题，一来是next主题已经用过很久了，有点审美疲劳，二来现在越来越喜欢暗色、简洁的主题。

于是稍微找了一下，选了一个挺喜欢、又很简洁的主题，为了让一些细枝末节也符合我的想法，我又fork了这个主题，做了一些破坏性的修改（捂脸

总体来说算是比较满意了，但是还有一个代码高亮不够好的问题，如下所示，但是目前勉强能看，也懒得费力解决了。

Figure 1: 代码高亮对比

总之这下有了比较好的写博客的环境，又少了一个摸鱼不写的理由（逃

在Gentoo Linux上使用dwm

2022-07-26T00:00:00Z

dwm全名为dynamic window manager，是suckless出品的主打简洁的窗口管理器。这里不多谈窗口管理器这个话题，我们主要说一下dwm都有哪些特点。

这里我将dwm和i3wm做一个简单的对比，这两者都是平铺窗口管理器，但是dwm和核心概念是标签(tag)，而i3wm的核心概念则是容器(container)，简单来说，dwm会给每个图形窗口打上tag，你可以选择显示某个tag或者某几个tag，与这些tag绑定的所有窗口都会被显示。在显示时，这些窗口会按照一定的布局排布，最基本的布局是一个主窗口占大部分空间，其他窗口平分剩下的空间。i3wm则是有若干个工作区，每个工作区内是一个容器构成的树，每个容器内可以包含子容器和程序窗口，你可以定义每个容器内的布局，比如分割方向，分割比例等。同一时刻，i3wm只能显示一个工作区。因此，i3wm可以手动实现更精细的布局控制，但是其他方面来说，不如dwm灵活，而布局这件事，我个人认为只需要几种自己常用的即可。因此我个人也是比较偏爱dwm。当然还有其他一些优秀的窗口管理器也有类似的特性，这里就不多介绍了。

dwm是使用c语言实现的，与一般的这类软件不同，dwm只包含大概两千多行代码，没有实现运行时的配置解析，而是将配置放到了一个c语言的头文件内，这样修改该头文件之后，编译即可得到一个配置过的dwm。这算是suckless软件的一种理念，我个人了解不多，这里就不多谈了。总之dwm不具备运行时解析配置的能力，更改配置之后，需要重新编译才能生效。这种配置方式并不是这种理念最有意思的地方，而是这种方式强迫用户自己对dwm进行修改，从而产生了补丁(patch)。

dwm的代码相当简洁，本身只具备非常基本的功能，即使是你进行了详细的配置，dwm也只能说是勉强可用的程度，因此很多用户为dwm编写了各种补丁，为dwm添加各种功能，也就是说，作为用户，你可以选择给dwm打上你想要的补丁，来让你自己的dwm更符合自己的需求，无论这些功能是否被官方认可。如果你自己熟悉c语言，只要花上一些时间读懂dwm的源代码，你也可以自己编写自己的补丁，来实现自己想要的但是别人没做的功能。这就让dwm具备了无限可能，一般的窗口管理器，你只能接受官方的设计，即使开放源代码，也一般因为过于复杂，造成大部分用户无力修改，从而没有多少补丁可用。而dwm则因为简洁的代码，而拥有其他窗口管理器不具备的定制能力。通过补丁，用户可以给dwm添加新功能、新布局、修改外观等等。

当然这样做的缺点也是显然的，要定制就必须有一定的定制能力，虽然说现在简单的定制已经可以说是毫无难度了，但如果要定制dwm，最好还是具备一些基本的c语言功底、编译常识、常用工具的使用、代码冲突解决的能力。如果补丁数量很多的话，要管理这些补丁、解决补丁之间的冲突，这些成本也是很高的。

Gentoo由于本身是一个源码编译的发行版，在包管理器设计上就给源码编译的软件留足了空间，对于dwm来说，Gentoo可以说是一个非常合适的发行版了。具体来说，Gentoo具备用户自定义补丁、保留配置等功能。同时，Gentoo官方源内的dwm包还提供了一个session文件用于登陆时自动启动程序。

因此以下就主要介绍一下，我是怎么在Gentoo下使用dwm的。

首先Gentoo上的dwm包提供了一个session文件，当你通过display manager启动dwm的时候，会自动运行 ~/.dwm/dwmrc 这个启动脚本，在这个脚本里，你可以自己启动一些自己常用的程序，比如我就是抄了一位大佬的脚本，做了启动fcitx5，picom，定时换壁纸之类的事情，这样，就不再需要给dwm打autostart之类的补丁了。当然如果你想用startx这种方式启动dwm，这个脚本是不会执行的。我之前在用这种方式启动的时候，就碰到了一些D-bus相关的问题，最后没有很好的解决，还是换成了简单易用的dm。

Gentoo提供了比较方便的补丁机制，当用户安装某个软件，需要打补丁的时候，只需要将补丁放入一个特定的文件夹，portage在构建时，便会自动打上这些补丁，再进行编译。具体来说，补丁目录是 /etc/portage/patches/<category>/<package> ，这里的category和package分别是包类别和包名，package还可以指定版本。像我目前只选择了少数不冲突的补丁，我只需要把这些补丁一股脑的放到 /etc/portage/patches/x11-wm/dwm-6.2/ 文件夹内，就能正常的用包管理安装dwm，同时又打上我需要的补丁。

此外部分包还提供了savedconfig这个use，当启用这个use的时候，portage会将构建时需要的配置文件存在一个地方，在构建包时，就能自动应用这些配置，对于dwm来说，这个配置文件就是dwm的头文件 config.h ，当你修改好这个文件后，将它存成 /etc/portage/savedconfig/x11-wm/dwm-6.2 这个文件(因为这个文件后缀名不是.c，所以文件编辑器一般不会高亮显示，如果是vim，可以手动执行 set ft=c 指令)，在编译前，portage就会自动将这个文件替换成 config.h。这样当你修改了配置之后，你只需要重新emerge一次dwm，就能更新好dwm了，当然这些改动还需要重启dwm才能真正生效。

总的来说，上面说的这些，都是为了能让dwm能完全由包管理管理。对于软件包来说，我个人是比较倾向于能交给包管理器的，都一律交给包管理处理。因为这样相对来说比较简单而且比较“干净”，用户只需要维护一份配置，就能够简单的重新构建出一套相同的环境。总的来说，要做到这点，还是不那么容易的，比如Arch这样的发行版，你要做到这点，要么是自己维护一个AUR脚本，要么是修改通用的AUR脚本。对我这种懒到极致的人来说，还是有点不友好的。而类似debian的发行版，则可能只能直接 make install 了。

Leetcode刷题笔记 6

2021-07-11T00:00:00Z

本周Leetcode刷题笔记

本周也是划水的一周，咳嗽断断续续，还忙里抽闲玩游戏，所以基本只随意做了些题目。

876. Middle of the Linked List

Given a non-empty, singly linked list with head node head, return a middle node of linked list.

If there are two middle nodes, return the second middle node.

获取链表的中点，经典快慢指针

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode *fast = head, *slow = head;
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }
};

1582. Special Positions in a Binary Matrix

Given a rows x cols matrix mat, where mat[i][j] is either 0 or 1, return the number of special positions in mat.

A position (i,j) is called special if mat[i][j] == 1 and all other elements in row i and column j are 0 (rows and columns are 0-indexed).

简单题，我的做法其实比较繁琐

class Solution {
public:
    int numSpecial(vector<vector<int>>& mat) {
        int m = mat.size(), n = mat.back().size(), ans = 0;
        for (int i = 0; i < m; i++) {
            int idx = -1, cnt = 0, s = 0;
            for (int j = 0; j < n; j++) {
                if (mat[i][j]) {
                    idx = j;
                    cnt++;
                }
            }
            if (cnt == 1) {
                for (int k = 0; k < m; k++) {
                    s += mat[k][idx];
                }
                if (s == 1) {
                    ans++;
                }
            }
        }
        return ans;
    }
};

这里推荐一个简单的做法，当然是我从讨论里抄来的

int numSpecial(vector<vector<int>>& mat) {
    vector<int> rows(mat.size()), cols(mat[0].size());
    for (int i = 0; i < rows.size(); ++i)
        for (int j = 0; j < cols.size(); ++j) {
            if (mat[i][j])
                ++rows[i], ++cols[j];
        }
    int res = 0;
    for (int i = 0; i < rows.size(); ++i)
        for (int j = 0; j < cols.size(); ++j)
            if (mat[i][j] && rows[i] == 1 && cols[j] == 1)
                ++res;
    return res;
}

236. Lowest Common Ancestor of a Binary Tree

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”

思考的时候有点问题，以为是个很简单的题目，实际上p和q的父节点是无法直接获取的，因此我们无法轻易的获取整棵树的层次结构。先看代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* helper(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == p || root == q || root == nullptr) {
            return root;
        }
        auto l = helper(root->left, p, q), r = helper(root->right, p, q);
        if (l && r) {
            return root;
        }
        return l ? l : r;
    }

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        return helper(root, p, q);
    }
};

如果碰到了p或者q，就返回该节点，其他情况下，我们返回的都是空指针，这样在递归返回之后，我们就可以判断p节点或者q节点是否在该根节点下。对于根节点，我们分别遍历他的左右节点，如果返回的结果均不为空指针，则说明p和q分别在跟节点的左右节点下，因此p和q的最低公共祖先即为根节点本身。如果返回的结果只有一个有效节点，另一个是空指针，则我们只需要返回该结果即可。

637. Average of Levels in Binary Tree

Given the root of a binary tree, return the average value of the nodes on each level in the form of an array. Answers within 10-5 of the actual answer will be accepted.

层序遍历求每层的平均值，我个人比较喜欢双队列的做法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        deque<TreeNode *> dq, swp;
        vector<double> ans;
        dq.push_back(root);
        long long sum = 0, cnt = 0;
        while (!dq.empty()) {
            sum = 0, cnt = 0;
            while (!dq.empty()) {
                auto node = dq.front();
                dq.pop_front();
                sum += node->val;
                cnt++;
                if (node->left) {
                    swp.push_back(node->left);
                }
                if (node->right) {
                    swp.push_back(node->right);
                }
            }
            ans.push_back(1.0 * sum / cnt);
            swap(dq, swp);
        }
        return ans;
    }
};

985. Sum of Even Numbers After Queries

We have an array nums of integers, and an array queries of queries.

For the i-th query val = queries[i][0], index = queries[i][1], we add val to nums[index]. Then, the answer to the i-th query is the sum of the even values of A.

(Here, the given index = queries[i][1] is a 0-based index, and each query permanently modifies the array nums.)

Return the answer to all queries. Your answer array should have answer[i] as the answer to the i-th query.

简单题，根据相应的query更新结果即可。

class Solution {
    public:
        vector<int> sumEvenAfterQueries(vector<int>& nums, vector<vector<int>>& queries) {
            vector<int> ans;
            int s = 0;
            for (const auto n : nums) {
                if (n % 2 == 0) {
                    s += n;
                }
            }
            for (const auto query : queries) {
                int val = query[0], idx = query[1];
                int v1 = nums[idx], v2 = v1 + val;
                s -= v1 % 2 == 0 ? v1 : 0;
                s += v2 % 2 == 0 ? v2 : 0;
                nums[idx] += val;
                ans.push_back(s);
            }
            return ans;
        }
};

829. Consecutive Numbers Sum

Given a positive integer n, how many ways can we write it as a sum of consecutive positive integers?

某次面试的时候做过这个题，不过当时没有细想，写的非常丑，这次仔细思考了一下，发现其实比较简单。

class Solution {
public:
    int consecutiveNumbersSum(int n) {
        int ans = 0;
        for (int i = 1; (i - 1) * i < 2 * n; i++) {
            if ((n - (i - 1) * i / 2) % i == 0) {
                ans++;
            }
        }
        return ans;
    }
};

假设一共有k个数，第一个数为a，则这些数的总和为 $𝑠 = \frac{(𝑎 + 𝑎 + 𝑘 - 1) \times 𝑘}{2}$ ，那么我们可以得到 $𝑎 = \frac{𝑠 - \frac{1}{2} (𝑘 - 1) 𝑘}{𝑘}$ ，能表示为连续整数之和等价于a为整数，而a为整数等价于(s - k * (k - 1) / 2) % k == 0。我们从k=1开始遍历，直到s - k * (k - 1) / 2小于0为止。

接下来是本周的双周赛和周赛，本周双周赛我做的还行，虽然最后一题还是不会。周赛因为最后两题都难度很大，所以做的比较差，总之这周还行吧，继续加油。

1925. Count Square Sum Triples

A square triple (a,b,c) is a triple where a, b, and c are integers and a2 + b2 = c2.

Given an integer n, return the number of square triples such that 1 <= a, b, c <= n.

签到题，o(N^3)算法走起

class Solution {
public:
    int countTriples(int n) {
        int ans = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = i; j <= n; j++) {
                for (int k = i + 1; k <= n; k++) {
                    if (i * i + j * j == k * k) {
                        ans += 2;
                    }
                }
            }
        }
        return ans;
    }
};

1926. Nearest Exit from Entrance in Maze

You are given an m x n matrix maze (0-indexed) with empty cells (represented as ‘.’) and walls (represented as ‘+’). You are also given the entrance of the maze, where entrance = [entrancerow, entrancecol] denotes the row and column of the cell you are initially standing at.

In one step, you can move one cell up, down, left, or right. You cannot step into a cell with a wall, and you cannot step outside the maze. Your goal is to find the nearest exit from the entrance. An exit is defined as an empty cell that is at the border of the maze. The entrance does not count as an exit.

Return the number of steps in the shortest path from the entrance to the nearest exit, or −1 if no such path exists.

寻路问题，返回最短路径的长度，简单的BFS即可。这里因为我个人比较喜欢双队列的trick，又有点嫌麻烦没用deque<pair<int,int>>而是直接用了deque<int>，所以写的不是很明白。不过大体思路基本都没什么问题，就懒得改了。

class Solution {
public:
    int nearestExit(vector<vector<char>>& maze, vector<int>& entrance) {
        int h = maze.size(), w = maze.back().size(), x = entrance[1], y = entrance[0];
        maze[y][x] = '*';
        deque<int> dq, swp;
        int di[][2] = { {0, 1}, {1, 0}, {-1, 0}, {0, -1} };
        int ans = 0;
        dq.push_back(y * w + x);
        while (!dq.empty()) {
            ans++;
            while (!dq.empty()) {
                int k = dq.front();
                dq.pop_front();
                int m = k / w, n = k % w;
                for (auto [a, b] : di) {
                    int s = m + a, d = n + b;
                    if (0 <= s && s < h && 0 <= d && d < w) {
                        if (maze[s][d] == '.') {
                            maze[s][d] = '*';
                            if (s == 0 || s == h - 1 || d == 0 || d == w - 1) {
                                return ans;
                            }
                            swp.push_back(s * w + d);
                        }
                    }
                }
            }
            swap(dq, swp);
        }
        return -1;
    }
};

1927. Sum Game

Alice and Bob take turns playing a game, with Alice starting first.

You are given a string num of even length consisting of digits and ‘?’ characters. On each turn, a player will do the following if there is still at least one ‘?’ in num:

Choose an index i where num[i] == ‘?’. Replace num[i] with any digit between ‘0’ and ‘9’. The game ends when there are no more ‘?’ characters in num.

For Bob to win, the sum of the digits in the first half of num must be equal to the sum of the digits in the second half. For Alice to win, the sums must not be equal.

For example, if the game ended with num = “243801”, then Bob wins because 2+4+3 = 8+0+1. If the game ended with num = “243803”, then Alice wins because 2+4+3 != 8+0+3. Assuming Alice and Bob play optimally, return true if Alice will win and false if Bob will win.

本周做出的最难题目，大意是两人玩游戏，有一个长度为偶数只包含数字或问号的字符串，由AB两人分别将问号替换为具体的数字，A的目的是使字符串前后两半的和不相等，而B的目的则相反。假设A和B都使用最佳策略，问A是否必胜。

首先很容易想到的一点是，假如问号个数为奇数个，则A必胜。因为此时由A最后操作，而A只需要两边不相等即可，因此A必胜。

另外一个点则是，如果两边都有问号，则这些问号可以被抵消。这一点没有严格的证明，但是我们可以这样稍微思考一下，作为A来说，他是希望两边的差尽可能大的，因此他可以在和比较大的那边放9，而作为回应，B只能在另外一边同样放9来抵消这个差距。因此这些问号就这样被抵消了。

当我们抵消完某一边的问号之后，真正的问题就浮出水面了。我们先考虑一个简单例子：52??，这个例子A是必胜的，只要A将某一个问号替换为9，那么无论如何B都失败了。为什么会这样，因为左边的和为7小于9，那么大于9如何呢？99??，A也是必胜的，A只需要将其中某个问号替换为0，则B无论如何也会失败。那么等于9呢，54??，这样的情况则B是必胜的，为什么，因为无论A将某一个问号替换成多少，都存在另一个对应的数，可以让两边相等。到这里我们大致有了一些思路，也就是如果一对问号如果换成两个和为9的数，能让两边的和相等，则B必胜，否则A必胜。如果有多对问号，则每对问号都需要满足这个条件。

分析到这里，题目就做出来了，当然我的代码写的很差，这里我放上我写的代码和某大佬的代码做对比。

class Solution {
public:
    bool sumGame(string num) {
        int n = num.length(), half = n / 2;
        int s1 = 0, s2 = 0, cnt1 = 0, cnt2 = 0;
        for (int i = 0; i < half; i++) {
            if (num[i] == '?') {
                cnt1++;
            } else {
                s1 += num[i] - '0';
            }
        }
        for (int i = half; i < n; i++) {
            if (num[i] == '?') {
                cnt2++;
            } else {
                s2 += num[i] - '0';
            }
        }
        if (cnt1 + cnt2 == 0) {
            return s1 != s2;
        }
        if ((cnt1 + cnt2) % 2 == 1) {
            return true;
        }
        if (cnt1 == cnt2 && s1 == s2) {
            return false;
        }
        if ((cnt1 > cnt2 && s1 > s2) || (cnt1 < cnt2 && s1 < s2)) {
            return true;
        }
        return cnt1 > cnt2 ? s2 - s1 != (cnt1 - cnt2) / 2 * 9 : s1 - s2 != (cnt2 - cnt1) / 2 * 9;
    }
};

class Solution {
public:
    bool sumGame(string num) {
        int n = num.length(), x = 0, a = 0, b = 0;
        for (int i = 0; i < n / 2; i++) {
            num[i] == '?' ? a++ : x += num[i] - '0';
        }
        for (int i = n / 2; i < n; i++) {
            num[i] == '?' ? b++ : x -= num[i] - '0';
        }
        if (a + b & 1) {
            return true;
        }
        return x - 9 * b + (a + b) / 2 * 9;
    }
};

1929. Concatenation of Array

Given an integer array nums of length n, you want to create an array ans of length 2n where ans[i] == nums[i] and ans[i + n] == nums[i] for 0 <= i < n (0-indexed).

Specifically, ans is the concatenation of two nums arrays.

Return the array ans.

周赛签到题，不提。

class Solution {
public:
    vector<int> getConcatenation(vector<int>& nums) {
        int n = nums.size();
        for (int i = 0; i < n; i++) {
            nums.push_back(nums[i]);
        }
        return nums;
    }
};

1930. Unique Length-3 Palindromic Subsequences

Given a string s, return the number of unique palindromes of length three that are a subsequence of s.

Note that even if there are multiple ways to obtain the same subsequence, it is still only counted once.

A palindrome is a string that reads the same forwards and backwards.

A subsequence of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters.

For example, “ace” is a subsequence of “abcde”.

周赛第二题，求字符串的子序列里长度为3的回文子序列有多少。字符串本身只由26个小写字母构成。

这个题的切入点在于虽然字符串总长度可能非常长，但字符串本身只由26个小写字母构成，而长度为3的回文子序列的总量很有限，只有最多26x26=676个，那么我们可以将每种字符的下标存储下来，再穷举所有的回文序列，判断该序列是否存在于字符串中。

class Solution {
public:
    int countPalindromicSubsequence(string s) {
        int ans = 0;
        vector<vector<int>> idx(26);
        for (int i = 0; i < s.length(); i++) {
            // 记录下所有字符对应的坐标，这里的坐标肯定是递增的
            idx[s[i] - 'a'].push_back(i);
        }
        for (int i = 0; i < 26; i++) {
            for (int j = 0; j < 26; j++) {
                // 判断子序列 { 'a' + i, 'a' + j, 'a' + i } 是否存在
                if (idx[i].size() < 2 || idx[j].empty()) {
                    // 显然不成立
                    continue;
                }
                // 这里l是字符i首次出现的位置，r是最后出现的位置
                // 我们需要确定字符j是否在区间(l, r)内出现过
                int l = idx[i].front(), r = idx[i].back();
                // [it1, it2) 是一个区间，区间内的坐标k均满足 l < k < r，因此如果该区间不为空，则我们可以得到一个回文子序列
                auto it1 = upper_bound(idx[j].begin(), idx[j].end(), l);
                auto it2 = lower_bound(idx[j].begin(), idx[j].end(), r);
                if (it1 != it2) {
                    ans++;
                }
            }
        }
        return ans;
    }
};

这个问题的另一个思路是，对于每种可能的字符，我们都获取它们的最左和最右的位置，然后将所有中间的字符都算做一种，这种方法需要用set来进行去重。也比较简单，我这里就不写了。

总的来说，这周的双周赛做的还不错，周赛就很一般了，不过这周周赛难度确实比较大，也是没办法的事，下周加油。另外最近发现vim真的挺好用的，定义个宏啥的真的可以省非常多操作。

Leetcode刷题笔记 5

2021-07-04T00:00:00Z

本周Leetcode刷题笔记

本周嗓子一直在咳嗽，去医院检查结果是急性呼吸道感染，吃了点药，也只能说好了点，但是没完全好。anyway，总之我就趁机偷懒了一点，基本上多找了点简单题做做，然后这周也没有双周赛，所以总的来说这周做题量比以往小。然后这周也懒得写之前做的题的笔记了。

867. Transpose Matrix

Given a 2D integer array matrix, return the transpose of matrix.

The transpose of a matrix is the matrix flipped over its main diagonal, switching the matrix’s row and column indices.

矩阵转置，很简单不说了

vector<vector<int>> transpose(vector<vector<int>>& matrix) {
    int m = matrix.size(), n = matrix.back().size();
    vector<vector<int>> ans(n, vector<int>(m));
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            ans[j][i] = matrix[i][j];
        }
    }
    return ans;
}

678. Valid Parenthesis String

Given a string s containing only three types of characters: ‘(‘, ‘)’ and ‘*’, return true if s is valid.

The following rules define a valid string:

Any left parenthesis ‘(‘ must have a corresponding right parenthesis ‘)’.
Any right parenthesis ‘)’ must have a corresponding left parenthesis ‘(‘.
Left parenthesis ‘(‘ must go before the corresponding right parenthesis ‘)’.
‘*’ could be treated as a single right parenthesis ‘)’ or a single left parenthesis ‘(‘ or an empty string ““.

这个题挺有意思的，是之前合法括号字符串的进阶版，引入*作为通配符。星号可以作为左括号，右括号或者空。这个题我没有想出特别好的做法，我主要的想法还是暴力，但是这样对于一些星号很多的特殊样例，绝对会超时。因为这个题的括号只有一种，用贪心的想法是比较好解决的，而关键是如何思考到正确的贪心解法。下面介绍两种别人的贪心解法。

数左括号个数。这个做法的思路在于我们数左括号的个数，根据这个数决定我们后续需要多少个右括号配对。问题在于星号的不确定性，因此我们维护一个范围[cmin, cmax]，cmin表示我们最少需要这么多个右括号来匹配，cmax表示我们最多可以匹配这么多个右括号。那么怎么样才是不合法的呢？如果在任意时刻，cmax小于0，则说明我们没有足够的左括号来匹配右括号，因此是不合法的。当我们到达字符串的结尾，此时我们已经没有更多的括号可以匹配了，如果此时cmin不等于0，则说明我们存在没有进行匹配的括号，那么也是不合法的。
双栈模拟。双栈模拟的想法是当我们遇到右括号时，我们应当优先使用左括号进行配对，因为星号是通配符，它可以适用于更多情景。双栈模拟的步骤稍微复杂一些，但我个人觉得更加容易理解一点。双栈模拟的思路是用两个栈保存左括号和星号的位置，当我们遇到右括号时，我们优先使用左括号进行配对。如果没有可以配对的左括号，那么再使用星号进行配对。双栈模拟分为2步，第1步是模拟配对过程，第2步是为剩余没有被配对的左括号寻找匹配的星号。
1. 第1步，如果碰到一个右括号时，左括号和星号的栈都为空，则说明这个右括号没有能与之配对的符号，字符串非法。否则优先使用左括号配对，一直到字符串结束。
2. 第2步我们进一步检查两个栈里剩余的字符。我们的目的是为每一个左括号都匹配上相应的右括号(使用剩余的星号)。因此这里存在一个要求，每一个左括号必须在对应的星号前面，否则它们是无法进行配对的。这也是为什么我们要使用栈来存储位置的原因。最后如果每一个剩余的左括号都能配对成功，那么整个字符串都是合法的，至于剩余的星号，我们无需关心。

// 第1种做法
bool checkValidString(string s) {
    int minl = 0, maxl = 0;
    for (const auto c : s) {
        if (c == '(') {
            minl++, maxl++;
        } else if (c == ')') {
            // minl是我们必须匹配的左括号数量，自然大于小于0
            minl = max(minl - 1, 0);
            maxl--;
        } else {
            // 碰到星号时，minl当成右括号，maxl当成左括号
            minl = max(minl - 1, 0);
            maxl++;
        }
        if (maxl < 0) {
            return false;
        }
    }
    return minl == 0;
}

// 双栈模拟
bool checkValidString(string s) {
    vector<int> open, star;
    for (int i = 0; i < s.length(); i++) {
        if (s[i] == '(') {
            open.push_back(i);
        } else if (s[i] == ')') {
            if (open.empty() && star.empty()) {
                // 两个栈都为空，false
                return false;
            }
            // 优先匹配左括号
            if (!open.empty()) {
                open.pop_back();
            } else {
                star.pop_back();
            }
        } else {
            star.push_back(i);
        }
    }
    while (!open.empty()) {
        int idx = open.back();
        open.pop_back();
        // 如果星号栈为空或者栈顶坐标小于左括号坐标，false
        if (star.empty() || star.back() < idx) {
            return false;
        }
        star.pop_back();
    }
    return true;
}

总的来说其实两种方法都是贪心的思路，这里我也没有严格证明这两种方法都是对的，没办法我实在是太菜了。

1636. Sort Array By Increasing Frequency

Given an array of integers nums, sort the array in increasing order based on the frequency of the values. If multiple values have the same frequency, sort them in decreasing order.

Return the sorted array.

按照数组内元素的出现次数排序，没啥好说的，哈希表统计一下出现次数，再按照哈希表数据排序即可。

vector<int> frequencySort(vector<int>& nums) {
    unordered_map<int, int> cnt;
    for (const auto n : nums) {
        cnt[n]++;
    }
    sort(nums.begin(), nums.end(), [&cnt](int a, int b) {
        return cnt[a] == cnt[b] ? a > b : cnt[a] < cnt[b];
    });
    return nums;
}

48. Rotate Image

You are given an n x n 2D matrix representing an image, rotate the image by 90 degrees (clockwise).

You have to rotate the image in-place, which means you have to modify the input 2D matrix directly. DO NOT allocate another 2D matrix and do the rotation.

旋转nxn的图像/Matrix，要求原地旋转不申请另外一块图像/Matrix内存。

我的想法其实比较笨，类似于每次都旋转四个对应的位置，比如四个角，又或者(1,0),(n-1,1),(n-2,n-1),(0,n-2)，然后循环的选取应该旋转的位置。

void rotate(vector<vector<int>>& matrix) {
    int n = matrix.size();
    for (int i = 0; i < n / 2; i++) {
        int k = n - 2 * i;
        for (int j = 0; j < k - 1; j++) {
            swap(matrix[i][i + j], matrix[i + j][i + k - 1]);
            swap(matrix[i][i + j], matrix[i + k - j - 1][i]);
            swap(matrix[i + k - j - 1][i], matrix[i + k - 1][i + k - j - 1]);
        }
    }
}

实际上存在更加通用的做法，即先做行反转，再做转置。包括逆时针旋转也有先做列反转，再做转置的做法。

void rotate(vector<vector<int> > &matrix) {
    reverse(matrix.begin(), matrix.end());
    for (int i = 0; i < matrix.size(); ++i) {
        for (int j = i + 1; j < matrix[i].size(); ++j)
            swap(matrix[i][j], matrix[j][i]);
    }
}

690. Employee Importance

You have a data structure of employee information, which includes the employee’s unique id, their importance value, and their direct subordinates’ id.

You are given an array of employees employees where:

employees[i].id is the ID of the ith employee.
employees[i].importance is the importance value of the ith employee.
employees[i].subordinates is a list of the IDs of the subordinates of the ith employee.

Given an integer id that represents the ID of an employee, return the total importance value of this employee and all their subordinates.

员工重要度，这个题目没啥好说的，本质上就是构造一个树求子树的和，当然并不需要真的构造一个树的数据结构，只要能表达这个关系即可。分为递归和队列的写法，也都差不多，递归写法这边就懒得写了。

int getImportance(vector<Employee*> employees, int id) {
    int ans = 0;
    unordered_map<int, Employee*> m;
    for (const auto em : employees) {
        m[em->id] = em;
    }
    deque<int> q;
    q.push_back(id);
    while (!q.empty()) {
        id = q.front();
        q.pop_front();
        ans += m[id]->importance;
        for (const auto k : m[id]->subordinates) {
            q.push_back(k);
        }
    }
    return ans;
}

1162. As Far from Land as Possible

Given an n x n grid containing only values 0 and 1, where 0 represents water and 1 represents land, find a water cell such that its distance to the nearest land cell is maximized, and return the distance. If no land or water exists in the grid, return −1.

The distance used in this problem is the Manhattan distance: the distance between two cells (x0, y0) and (x1, y1) is |x0 - x1| + |y0 - y1|.

求海面离岛屿的最大曼哈顿距离。正常来说这个题的思考是从海面出发，比如做DP啥的，但我也没想出特别好的做法。实际上从岛屿出发还比较容易写，时间复杂度也比较低，为o(n^2)。不过需要使用两个队列的trick。

int maxDistance(vector<vector<int>>& grid) {
    int ans = -1, n = grid.size();
    vector<pair<int, int>> di = { {-1, 0}, {0, 1}, {1, 0}, {0, -1} };
    deque<pair<int, int>> dq, tmp;
    for (int i = 0; i < grid.size(); i++) {
        for (int j = 0; j < grid[i].size(); j++) {
            if (grid[i][j]) {
                dq.emplace_back(i, j);
            }
        }
    }

    while (!dq.empty()) {
        ans++;
        while (!dq.empty()) {
            auto [y, x] = dq.front();
            dq.pop_front();
            for (const auto &[dy, dx] : di) {
                int nx = x + dx, ny = y + dy;
                if (0 <= nx && nx < n && 0 <= ny && ny < n && grid[ny][nx] == 0) {
                    grid[ny][nx] = 1;
                    tmp.emplace_back(ny, nx);
                }
            }
        }
        swap(dq, tmp);
    }
    return ans ? ans : -1;
}

1041. Robot Bounded In Circle

On an infinite plane, a robot initially stands at (0, 0) and faces north. The robot can receive one of three instructions:

“G”: go straight 1 unit;
“L”: turn 90 degrees to the left;
“R”: turn 90 degrees to the right.

The robot performs the instructions given in order, and repeats them forever.

Return true if and only if there exists a circle in the plane such that the robot never leaves the circle.

这个题看着好像不是很容易，实际上只需要稍微分析就会发现，机器人行进距离发散的条件有且仅有一种，那就是当机器人走完一遍指令集后，运动方向不变且运动距离不为0。当且仅当这两者同时成立时，机器人的运动距离才不会被限制在一个圈内，或者说发散。于是剩下的就只有一些编程技巧了。

bool isRobotBounded(string instructions) {
    int dire[][2] = { {0, 1}, {1, 0}, {0, -1}, {-1, 0} };
    int idx = 0;
    int x = 0, y = 0;
    for (const auto c : instructions) {
        switch (c) {
            case 'G':
                x += dire[idx][0];
                y += dire[idx][1];
                break;
            case 'L':
                idx = (idx + 3) % 4;
                break;
            case 'R':
                idx = (idx + 1) % 4;
                break;
        }
    }
    return !(idx == 0 && (x != 0 || y != 0));
}

566. Reshape the Matrix

In MATLAB, there is a handy function called reshape which can reshape an m x n matrix into a new one with a different size r x c keeping its original data.

You are given an m x n matrix mat and two integers r and c representing the row number and column number of the wanted reshaped matrix.

The reshaped matrix should be filled with all the elements of the original matrix in the same row-traversing order as they were.

If the reshape operation with given parameters is possible and legal, output the new reshaped matrix; Otherwise, output the original matrix.

实现Reshape函数，没啥好说的

vector<vector<int>> matrixReshape(vector<vector<int>>& mat, int r, int c) {
    int m = mat.size(), n = mat.back().size();
    if (m * n != r * c) {
        return mat;
    }
    vector<vector<int>> ans(r, vector<int>(c));
    for (int i = 0; i < r * c; i++) {
        ans[i / c][i % c] = mat[i / n][i % n];
    }
    return ans;
}

100. Same Tree

Given the roots of two binary trees p and q, write a function to check if they are the same or not.

Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.

判断两颗二叉树是否是相同，也没啥好说的。

/*
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
// 递归写法
bool isSameTree(TreeNode* p, TreeNode* q) {
    if (!p && !q) {
        return true;
    }
    if (!p || !q) {
        return false;
    }
    if (p->val != q->val) {
        return false;
    }
    return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}

// 队列写法
bool isSameTree(TreeNode* p, TreeNode* q) {
    deque<pair<TreeNode*, TreeNode*>> dq;
    dq.emplace_back(p, q);
    while (!dq.empty()) {
        auto [a, b] = dq.front();
        dq.pop_front();
        if (a && b) {
            if (a->val != b->val) {
                return false;
            }
            dq.emplace_back(a->left, b->left);
            dq.emplace_back(a->right, b->right);
        } else if (a || b) {
            return false;
        }
    }
    return true;
}

700. Search in a Binary Search Tree

You are given the root of a binary search tree (BST) and an integer val.

Find the node in the BST that the node’s value equals val and return the subtree rooted with that node. If such a node does not exist, return null.

在BST上搜索，也很简单

/*
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */

// 递归写法
TreeNode* searchBST(TreeNode* root, int val) {
    if (!root || root->val == val) {
        return root;
    }
    return searchBST(root->val > val ? root->left : root->right, val);
}

// 循环写法
TreeNode* searchBST(TreeNode* root, int val) {
    auto p = root;
    while (p) {
        if (p->val == val) {
            break;
        } else if (p->val > val) {
            p = p->left;
        } else {
            p = p->right;
        }
    }
    return p;
}

1816. Truncate Sentence

A sentence is a list of words that are separated by a single space with no leading or trailing spaces. Each of the words consists of only uppercase and lowercase English letters (no punctuation).

For example, “Hello World”, “HELLO”, and “hello world hello world” are all sentences. You are given a sentence s and an integer k. You want to truncate s such that it contains only the first k words. Return s after truncating it.

简单不提

string truncateSentence(string s, int k) {
    int i = 0;
    while (k > 0 && i < s.length()) {
        if (s[i] == ' ') {
            k--;
        }
        i++;
    }
    return i == s.length() ? s.substr(0, i) : s.substr(0, i - 1);
}

46. Permutations

Given an array nums of distinct integers, return all the possible permutations. You can return the answer in any order.

这个题本身其实还是可以的，不过还是建议使用next_permutation，而且作为写完了Next_Permutation那题的人，我个人觉得这并不算作弊。

vector<vector<int>> permute(vector<int>& nums) {
    sort(nums.begin(), nums.end());
    vector<vector<int>> ans;
    do {
        ans.push_back(nums);
    } while (next_permutation(nums.begin(), nums.end()));
    return ans;
}

接下来是本周的周赛，本周周赛也是喜忧参半，喜的是本周周赛应该是我参加以来名次最好的一次了，忧的是这次的第四题也太难了，实在打击自信心。不过这次周赛的难度可以说是两个极端，前三题基本非常简单，最后一题也真的是难得发指。只能说下次加油。

1920. Build Array from Permutation

Given a zero-based permutation nums (0-indexed), build an array ans of the same length where ans[i] = nums[nums[i]] for each 0 <= i < nums.length and return it.

A zero-based permutation nums is an array of distinct integers from 0 to nums.length - 1 (inclusive).

连题目都没怎么看懂，但是基本上已经把做法写在了题目里，只能说签到题一般不会出现上周双周赛那样的。

vector<int> buildArray(vector<int>& nums) {
    vector<int> ans;
    for (const auto i : nums) {
        ans.push_back(nums[i]);
    }
    return ans;
}

1921. Eliminate Maximum Number of Monsters

You are playing a video game where you are defending your city from a group of n monsters. You are given a 0-indexed integer array dist of size n, where dist[i] is the initial distance in meters of the ith monster from the city.

The monsters walk toward the city at a constant speed. The speed of each monster is given to you in an integer array speed of size n, where speed[i] is the speed of the ith monster in meters per minute.

The monsters start moving at minute 0. You have a weapon that you can choose to use at the start of every minute, including minute 0. You cannot use the weapon in the middle of a minute. The weapon can eliminate any monster that is still alive. You lose when any monster reaches your city. If a monster reaches the city exactly at the start of a minute, it counts as a loss, and the game ends before you can use your weapon in that minute.

Return the maximum number of monsters that you can eliminate before you lose, or n if you can eliminate all the monsters before they reach the city.

模拟题，大意是类似植物大战僵尸，每个僵尸有一个距离和速度，它们不停的朝你走来，你有一个远程武器，可以在每分钟开始的时候消灭任意一个僵尸。但是如果任意僵尸靠近到了你身边，则游戏失败。如果一个僵尸在某一分钟开始的时候到达，则你来不及开枪，也算是失败。问你最多可以消灭多少僵尸。

这个问题其实很简单，我们关注的其实不是僵尸的距离或者速度，我们关注的是僵尸到达我们身边的时间，只不过这个时间不一定是整数的，因此我们可以新建一个double数组表示每个僵尸到达的时间，再对它们排序，最后我们按照顺序击杀僵尸即可。如果第i个僵尸在第i分钟之前到达了，那说明我们无法及时消灭它，即失败了。然后这边注意一下0-index还是1-index之类的细节即可。

int eliminateMaximum(vector<int>& dist, vector<int>& speed) {
    vector<double> reach;
    for (int i = 0; i < dist.size(); i++) {
        reach.push_back(1.0 * dist[i] / speed[i]);
    }
    sort(reach.begin(), reach.end());
    for (int i = 0; i < reach.size(); i++) {
        if (i >= reach[i]) {
            return i;
        }
    }
    return reach.size();
}

1922. Count Good Numbers

A digit string is good if the digits (0-indexed) at even indices are even and the digits at odd indices are prime (2, 3, 5, or 7).

For example, “2582” is good because the digits (2 and 8) at even positions are even and the digits (5 and 2) at odd positions are prime. However, “3245” is not good because 3 is at an even index but is not even.

Given an integer n, return the total number of good digit strings of length n. Since the answer may be large, return it modulo 109 + 7.

A digit string is a string consisting of digits 0 through 9 that may contain leading zeros.

计数题，也很简单，本质上因为0-9范围内，偶数有5个，质数有4个，因此本质上这个题就是求power(5, n / 2) * power(4, n / 2) * power(5, n % 2)，由于n非常大，所以需要实现快速幂，且需要对结果取模，但是这个也没有什么难度。

const int mod = 1000000007;

long long helper(long long n, int k) {
    if (n == 0) {
        return 1;
    }
    if (n == 1) {
        return k;
    }
    long long tmp = helper(n / 2, k) % mod;
    long long s = n % 2 ? k : 1;
    return tmp * tmp % mod * s % mod;
}

int countGoodNumbers(long long n) {
    if (n == 1) {
        return 5;
    }
    long long tmp1 = helper(n / 2, 5) % mod;
    long long tmp2 = helper(n / 2, 4) % mod;
    int tmp3 = n % 2 ? 5 : 1;
    return tmp1 * tmp2 % mod * tmp3 % mod;
}

最后一题实在有点超出我的能力范围，所以这里就不写了。总的来说这周虽然名次还ok，但是因为题目本身也比较简单，所以这个名次也没啥含金量，以后加油吧。

Leetcode刷题笔记 4

2021-06-27T00:00:00Z

本周Leetcode刷题笔记

309. Best Time to Buy and Sell Stock with Cooldown

You are given an array prices where prices[i] is the price of a given stock on the ith day.

Find the maximum profit you can achieve. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times) with the following restrictions:

After you sell your stock, you cannot buy stock on the next day (i.e., cooldown one day).

Note: You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).

因为这个问题规模不大，因此可以通过比较naive的DP来做，假设dp[i]是到第i步时在我们卖出股票的前提下，赚到的最多的钱。那么我们可以遍历前面的[0, i-1]区间内的步骤，来更新最大值。代码如下

int maxProfit(vector<int>& prices) {
    unordered_map<int, int> dp;
    int res = 0;
    for (int i = 1; i < prices.size(); i++) {
        for (int j = 0; j < i; j++) {
            dp[i] = max(dp[i], dp[j - 2] + max(prices[i] - prices[j], 0));
        }
        dp[i] = max(dp[i], dp[i-1]);
        res = max(res, dp[i]);
    }
    return res;
}

这个代码挺难理解的，写的比较差，复杂度也是o(n^2)的，实际上这个题目有更好的o(n)解法。以状态机的方式来思考，我们一共可能有三种状态:

s0 空闲状态，此时我们可以买入，也可以跳过下一次交易时间。买入则进入s1，跳过则保持在s0
s1 刚刚买入，此时可以跳过下一次交易时间也可以卖出。跳过下一次交易则我们保持在s1，卖出则进入s2
s2 刚刚卖出，此时只能跳过下一次交易时间。跳过后我们进入s0

我们可以看到，不同的状态有不同的进入方式，假如我们每一步都维持每个状态的最大值，那么最终我们需要的最大值就在s0和s2之间，因为s1刚刚买入显然不会是最大值。初始状态则如下：s0是空闲状态，因此是0，s1刚刚买入，所以初始值是-prices[0]，s2刚刚卖出其实是不可能出现的，我们将其初始化为最小值，防止影响我们的结果。同时这里其实也不需要使用vector存储状态，不过我这里就不改了。

int maxProfit(vector<int>& prices) {
    if (prices.size() <= 1) return 0;
    vector<int> s0(prices.size(), 0);
    vector<int> s1(prices.size(), 0);
    vector<int> s2(prices.size(), 0);
    s1[0] = -prices[0];
    s0[0] = 0;
    s2[0] = INT_MIN;
    for (int i = 1; i < prices.size(); i++) {
        s0[i] = max(s0[i - 1], s2[i - 1]);
        s1[i] = max(s1[i - 1], s0[i - 1] - prices[i]);
        s2[i] = s1[i - 1] + prices[i];
    }
    return max(s0[prices.size() - 1], s2[prices.size() - 1]);
}

95. Unique Binary Search Tree II

Given an integer n, return all the structurally unique BST’s (binary search trees), which has exactly n nodes of unique values from 1 to n. Return the answer in any order.

这个题要求返回由[1, n]区间内所有的数字构成的全部平衡二叉树。一般这种题我的第一反应只会是递归，思路也比较清晰，从[1,n]区间选一个数i作为根节点的值，再构造由[1, i-1]和[i+1, n]构成的平衡二叉树，作为根节点的左右节点。相比于使用[l, r]作为区间范围，我更偏向于使用由n和base表示的[1+base, n+base]区间范围，因为这样我可以在函数原型内加入一个默认形参，从而免去了另写一个helper函数的麻烦。代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */

vector<TreeNode*> generateTrees(int n, int base = 0) {
    vector<TreeNode*> ans;
    if (n == 0) {
        return ans;
    }
    if (n == 1) {
        ans.push_back(new TreeNode(n + base));
        return ans;
    }
    for (int i = 1; i <= n; i++) {
        auto vec1 = generateTrees(i - 1, base);
        auto vec2 = generateTrees(n - i, i + base);
        if (vec1.empty() && vec2.empty()) {
            ans.push_back(new TreeNode(i + base));
        } else if (vec1.empty()) {
            for (auto right : vec2) {
                ans.push_back(new TreeNode(i + base, nullptr, right));
            }
        } else if (vec2.empty()) {
            for (auto left : vec1) {
                ans.push_back(new TreeNode(i + base, left, nullptr));
            }
        } else {
            for (auto left : vec1) {
                for (auto right : vec2) {
                    ans.push_back(new TreeNode(i + base, left, right));
                }
            }
        }
    }
    return ans;
}

但是这边写的还是比较麻烦，其实主要原因出在当n=0时的返回值上，我返回了空集，因此需要做一些复杂的检查和处理。但是如果返回的是一个包含nullptr的集合，则根本不需要写这么复杂。另外这边需要注意的是，我们直接把返回的节点接入根节点上，在实际中会有严重的内存问题，但如果仅仅考虑通过这个问题，则无所谓。如下所示：

vector<TreeNode*> generateTrees(int n, int base = 0) {
    vector<TreeNode*> ans;
    if (n == 0) {
        return { nullptr };
    }
    for (int i = 1; i <= n; i++) {
        for (auto left : generateTrees(i - 1, base)) {
            for (auto right : generateTrees(n - i, i + base)) {
                ans.push_back(new TreeNode(i + base, left, right));
            }
        }
    }
    return ans;
}

1314. Matrix Block Sum

Given a m x n matrix mat and an integer k, return a matrix answer where each answer[i][j] is the sum of all elements mat[r][c] for:

i - k <= r <= i + k,
j - k <= c <= j + k, and
(r, c) is a valid position in the matrix.

这个问题相对来说比较简单，用前缀和的思路即可，不多说。

vector<vector<int>> matrixBlockSum(vector<vector<int>>& mat, int k) {
    int m = mat.size(), n = mat[0].size();
    vector<vector<int>> preSum(m + 1, vector<int>(n + 1, 0));
    vector<vector<int>> ans(m, vector<int>(n, 0));
    for (int i = 1; i < preSum.size(); i++) {
        for (int j = 1; j < preSum[i].size(); j++) {
            preSum[i][j] = preSum[i - 1][j] + preSum[i][j - 1] - preSum[i - 1][j - 1] + mat[i - 1][j - 1];
        }
    }
    for (int i = 0; i < ans.size(); i++) {
        for (int j = 0; j < ans[i].size(); j++) {
            int x1 = max(0, i - k), y1 = max(0, j - k);
            int x2 = min(m, i + k + 1), y2 = min(n, j + k + 1);
            ans[i][j] = preSum[x2][y2] - preSum[x1][y2] - preSum[x2][y1] + preSum[x1][y1];
        }
    }
    return ans;
}

50. Power(x, n)

Implement pow(x, n), which calculates x raised to the power n (i.e., $𝑥^{𝑛}$ ).

实现Power(x, n)，这个问题n范围比较大，需要使用快速幂算法，同时需要考虑n为0或者为负的情况。注意好这些细节就不算难写。

double myPow(double x, int n) {
    if (n == 0) {
        return 1.0;
    }
    if (n == 1) {
        return x;
    }
    bool neg = n < 0;
    n = abs(n);
    double tmp = myPow(x, n / 2);
    tmp = tmp * tmp * myPow(x, n % 2);
    return neg ? 1.0 / tmp : tmp;
}

1848. Minimum Distance to the Target Element

Given an integer array nums (0-indexed) and two integers target and start, find an index i such that nums[i] == target and abs(i - start) is minimized. Note that abs(x) is the absolute value of x.

Return abs(i - start).

It is guaranteed that target exists in nums.

简单题，朝两个方向遍历即可。

int getMinDistance(vector<int>& nums, int target, int start) {
    for (int i = 0; start + i < nums.size() || start - i >= 0; i++) {
        if (start + i < nums.size() && nums[start + i] == target || start - i >= 0 && nums[start - i] == target) {
            return i;
        }
    }
    return -1;
}

1704. Determine if String Halves are Alike

You are given a string s of even length. Split this string into two halves of equal lengths, and let a be the first half and b be the second half.

Two strings are alike if they have the same number of vowels (‘a’, ‘e’, ‘i’, ‘o’, ‘u’, ‘A’, ‘E’, ‘I’, ‘O’, ‘U’). Notice that s contains uppercase and lowercase letters.

Return true if a and b are alike. Otherwise, return false.

当天的又一个简单题，数前后两半的元音数。

bool isVowel(char c) {
    c = tolower(c);
    return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}

bool halvesAreAlike(string s) {
    int cnt1 = 0, cnt2 = 0;
    for (int i = 0; i < s.length() / 2; i++) {
        if (isVowel(s[i])) {
            cnt1++;
        }
        if (isVowel(s[s.length() - i - 1])) {
            cnt2++;
        }
    }
    return cnt1 == cnt2;
}

735. Asteroid Collision

We are given an array asteroids of integers representing asteroids in a row.

For each asteroid, the absolute value represents its size, and the sign represents its direction (positive meaning right, negative meaning left). Each asteroid moves at the same speed.

Find out the state of the asteroids after all collisions. If two asteroids meet, the smaller one will explode. If both are the same size, both will explode. Two asteroids moving in the same direction will never meet.

这个题还挺难的，首先我一直没有很好的思路，其次看了别人的思路也没写出自己的代码。这道题其实类似括号匹配，只不过这里匹配之后，需要摧毁其中一个或者全部，剩下的继续参与匹配，因此可以用栈实现。这个题的细节也很重要，什么时候入栈什么时候出栈，绝对值相等时怎么处理，etc，这里贴一段别人的代码。

vector<int> asteroidCollision(vector<int>& asteroids) {
    vector<int> ans;
    for (int i = 0; i < asteroids.size(); i++) {
        if (asteroids[i] > 0 || ans.empty() || ans.back() < 0) {
            ans.push_back(asteroids[i]);
        } else if (ans.back() <= -asteroids[i]) {
            if (ans.back() < -asteroids[i]) {
                i--;
            }
            ans.pop_back();
        }
    }
    return ans;
}

1720. Decode XORed Array

There is a hidden integer array arr that consists of n non-negative integers.

It was encoded into another integer array encoded of length n - 1, such that encoded[i] = arr[i] XOR arr[i + 1]. For example, if arr = [1,0,2,1], then encoded = [1,2,3].

You are given the encoded array. You are also given an integer first, that is the first element of arr, i.e. arr[0].

Return the original array arr. It can be proved that the answer exists and is unique.

简单题，利用异或的性质(A = B ^ C => B = A ^ C)即可，即使不知道性质，也可以在纸上推一推，总之比较简单。

vector<int> decode(vector<int>& encoded, int first) {
    vector<int> ans(1, first);
    for (auto n : encoded) {
        ans.push_back(ans.back() ^ n);
    }
    return ans;
}

31. Next Permutation

Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.

If such an arrangement is not possible, it must rearrange it as the lowest possible order (i.e., sorted in ascending order).

The replacement must be in place and use only constant extra memory.

日常题的最后一道，实现next permutation，将一个序列变为它的下一个字典序排列。这个题的算法其实比较简单，即使没有接触过，也可以自己推导出来，有点像手动实现+1，假设区间[1,n]，算法步骤如下：

找到使得[i, n]非严格单调递减的最大下标i
反转[i, n]区间，这里反转指逆序
如果i等于1，说明整个序列从最大字典序转换到了最小字典序，因此算法结束
找到[i, n]区间内第一个大于 $𝐴_{𝑖 - 1}$ 的数 $𝐴_{𝑘}$ ，即upper bound
交换 $𝐴_{𝑘}$ 和 $𝐴_{𝑖 - 1}$

整个算法就这5步，写起来也比较简单，我这里是当时实现的两个版本，第一个比较粗糙，第二个经过了一定的优化。这个题主要的作用还是帮我加深了对next permutation的理解，如果要使用这个函数遍历一个序列的全排列，那么必须先对这个序列进行排序。之前有一次机试我实际上就犯错了，不过当时运气好，测试样例很简单因此侥幸通过了。

void helper(vector<int>::iterator first, vector<int>::iterator last) {
    auto it = last - 1;
    while (it != first && *(it - 1) >= *it) {
        it--;
    }
    sort(it, last);
    if (it != first) {
        auto k = it - 1;
        while (it != last - 1 && *k >= *it) {
            it++;
        }
        swap(*k, *it);
    }
}

void helper(vector<int>::iterator first, vector<int>::iterator last) {
    auto it = last - 1;
    while (it != first && *(it - 1) >= *it) {
        it--;
    }
    reverse(it, last);
    if (it != first) {
        auto iter = upper_bound(it, last, *(it - 1));
        swap(*(it - 1), *iter);
    }
}

void nextPermutation(vector<int>& nums) {
    helper(nums.begin(), nums.end());
}

然后是本周的双周赛，这次是我第一次参加双周赛，题目也不算很难，做出来三个，如果时间多点其实也可能能做出来第四个，不过无所谓了。

1909. Remove One Element to Make the Array Strictly Increasing

Given a 0-indexed integer array nums, return true if it can be made strictly increasing after removing exactly one element, or false otherwise. If the array is already strictly increasing, return true.

The array nums is strictly increasing if nums[i - 1] < nums[i] for each index (1 <= i < nums.length).

给一个数组，判定该数组是否可以通过仅仅删除一个元素就成为严格单调递增的数组。当时差点怀疑人生，因为这个题看起来好像简单，实则做起来却完全不是这样。但是这个题简单可能简单在数据不大，数组长度10000级别，也就是说o(n^2)的时间复杂度是可以通过的。因此暴力基本是最好的选择了。

bool canBeIncreasing(vector<int>& nums) {
    vector<int> vec;
    for (int i = 0; i < nums.size(); i++) {
        vec.clear();
        for (int j = 0; j < nums.size(); j++) {
            if (i != j) {
                vec.push_back(nums[j]);
            }
        }
        bool flag = true;
        for (int j = 1; j < vec.size(); j++) {
            if (vec[j-1] >= vec[j]) {
                flag = false;
            }
        }
        if (flag) {
            return true;
        }
    }
    return false;
}

1910. Remove All Occurrences of a Substring

Given two strings s and part, perform the following operation on s until all occurrences of the substring part are removed:

Find the leftmost occurrence of the substring part and remove it from s.

Return s after removing all occurrences of part.

A substring is a contiguous sequence of characters in a string.

这道题倒是没有什么好说的，比第一题简单多了，而且数据级别也很小，直接模拟即可。

string removeOccurrences(string s, string part) {
    auto it = s.find(part);
    while (it != -1) {
        s = s.substr(0, it) + s.substr(it + part.length());
        it = s.find(part);
    }
    return s;
}

1911. Maximum Alternating Subsequence Sum

The alternating sum of a 0-indexed array is defined as the sum of the elements at even indices minus the sum of the elements at odd indices.

For example, the alternating sum of [4,2,5,3] is (4 + 5) - (2 + 3) = 4. Given an array nums, return the maximum alternating sum of any subsequence of nums (after reindexing the elements of the subsequence).

A subsequence of an array is a new array generated from the original array by deleting some elements (possibly none) without changing the remaining elements’ relative order. For example, [2,7,4] is a subsequence of [4,2,3,7,2,1,4] (the underlined elements), while [2,4,2] is not.

这个题求序列的子序列最大Alternating Sum，Alternating Sum是序列的偶数下标的数总和减去奇数下标的数总和。这个题其实和之前做过的买股票的题类似，而且比那个更简单，只有两种状态：我们还是用买卖股票的例子来说明，买入和卖出都相当于我们选择了一个数加入子序列，但是他们的下标分别为奇数和偶数，我们也可以跳过，此时不选择该数进入子序列。假如和股票的题类比，这里我们的目标是其实是要亏损最大。

s0，刚买入股票，此时可以跳过或者卖出，跳过保持s0，卖出进入s1
s1，刚卖出股票，此时可以跳过或者买入，跳过保持s1，卖出进入s0

代码如下:

long long maxAlternatingSum(vector<int>& nums) {
    long long s1 = INT_MIN, s2 = 0;
    for (int i = 0; i < nums.size(); i++) {
        s1 = max(s1, s2 + nums[i]);
        s2 = max(s2, s1 - nums[i]);
    }
    return max(s1, s2);
}

这里其实我不太确定代码的正确性，理论上来说好像有点问题，当时提交的比较急，没有仔细检查，理论上应该先备份s1的值，在更新s2时使用备份的值而不是更新后的s1。但是总之通过了所有的测试样例。

双周赛的最后一题算是考察数据结构的设计，比较复杂，我就不写了。

然后是本周的周赛，本周周赛对我来说还是比较难的，只做出来两道题。

1913. Maximum Product Difference Between Two Pairs

The product difference between two pairs (a, b) and (c, d) is defined as (a * b) - (c * d).

For example, the product difference between (5, 6) and (2, 7) is (5 * 6) - (2 * 7) = 16. Given an integer array nums, choose four distinct indices w, x, y, and z such that the product difference between pairs (nums[w], nums[x]) and (nums[y], nums[z]) is maximized.

Return the maximum such product difference.

老老实实做可能还比较费劲，但是本题不需要考虑负数，因此直接排序选择前两位和后两位比较简单。

int maxProductDifference(vector<int>& nums) {
    int n = nums.size();
    sort(nums.begin(), nums.end());
    return nums[n-1] * nums[n-2] - nums[0] * nums[1];
}

1914. Cyclically Rotating a Grid

You are given an m x n integer matrix grid, where m and n are both even integers, and an integer k.

The matrix is composed of several layers, which is shown in the below image, where each color is its own layer:

Figure 2: image

A cyclic rotation of the matrix is done by cyclically rotating each layer in the matrix. To cyclically rotate a layer once, each element in the layer will take the place of the adjacent element in the counter-clockwise direction. An example rotation is shown below:

Figure 3: rotate

Return the matrix after applying k cyclic rotations to it.

这个题是究级烦，按照规则旋转矩阵的layer，我最后选择的做法是对每一层的坐标都做变换，得到转换前的坐标和转换后的坐标的关系。有多恶心就不提了。

int x1(int j, int a, int b) {
    return (0 <= j && j < b) ? 0 : b <= j && j <= a + b - 2 ? j - b + 1 : (a + b - 2 < j && j <= a + b * 2 - 3 ? a - 1 : 2 * a + 2 * b - j - 4);
}

int y1(int j, int a, int b) {
    return (0 <= j && j < b) ? j : b <= j && j <= a + b - 2 ? b - 1 : (a + b - 2 < j && j <= a + b * 2 - 3 ? a + 2 * b - j - 3 : 0);
}

vector<vector<int>> rotateGrid(vector<vector<int>>& grid, int k) {
    int m = grid.size(), n = grid.front().size(), l = min(m, n);
    vector<vector<int>> ans = grid;
    for (int i = 0; i < l / 2; i++) {
        int a = m - i * 2, b = n - i * 2, c = a * 2 + b * 2 - 4;
        for (int j = 0; j < c; j++) {
            int x = i + x1(j, a, b);
            int y = i + y1(j, a, b);
            int s = i + x1((j + k) % c, a, b), f = i + y1((j + k) % c, a, b);
            ans[x][y] = grid[s][f];
        }
    }
    return ans;
}

接下来的两道题我都基本没有思路，可以说是完全不会，连别人的题解都还没理解，就先不写了。这周周赛还是挺惨的，感觉还是基础不行啊，继续加油吧。

Leetcode刷题笔记 3

2021-06-25T00:00:00Z

9. Palindrome Number

Q: Given an integer x, return true if x is palindrome integer.

An integer is a palindrome when it reads the same backward as forward. For example, 121 is palindrome while 123 is not.

判断一个数是否为回文数，本题判定负数均不属于回文数。最简单的思路当然是把数字转成字符串或者字符数组，然后判定是否是回文。但是题目进阶的要求是不做这个转化，这样这个题目就有难度了。这里会用到一个比较巧妙的技巧，我们通过这个技巧得到这个数的前半部分和后半部分的反转，从而判定整个数是否是回文数。具体来说，我们一边将这个数除10，一边将除10的余数构造成另一个数，然后这个过程中，我们可以根据这两个数而判定原数是否是回文数。举个例子，如1234321，每次循环我们可以得到如下数字<123432, 1>,<12345, 12>,<1234,123>，进行到这里就足够了，因为这里1234/10==123，因此我们就可以判定1234321是回文数，如果原数是偶数位的，那我们判定两数是否相等。但是这种做法对于一些特例是不成立的，当x有后置0且x本身不为0时，我们相当于在判定x/10是否为回文数，而结论不成立。因此我们只需要判断是否是特例，再根据这种做法判定即可。以下分别是我自己的代码和别人相同思路的代码。

// mine
bool isPalindrome(int x) {
    if (x < 0 || x % 10 == 0 && x != 0) { return false; }
    int k = 0;
    while (x >= k) {
        if (x == k || x / 10 == k) {
            return true;
        }
        k = k * 10 + x % 10;
        x = x / 10;
    }
    return false;
}

bool isPalindrome(int x) {
    if (x < 0 || x % 10 == 0 && x != 0) { return false; }
    int reverse = 0;
    while (reverse < x) {
        reverse = reverse * 10 + x % 10;
        x /= 10;
    }
    return x == reverse || reverse / 10 == x;
}

10. Regular Expression Matching

Q: Given an input string (s) and a pattern (p), implement regular expression matching with support for ‘.’ and ‘*’ where:

‘.’ Matches any single character.
‘*’ Matches zero or more of the preceding element.

The matching should cover the entire input string (not partial).

这个题要求实现简单的正则匹配功能，我的第一反应是递归，思路相对比较简单，只是写起来比较繁琐。这里不再赘述思路，况且过了比较长时间了，这种题的思路也比较复杂，也不是想说就能说明白的。

bool isMatch(string s, string p) {
    char c;
    if (p.empty()) {
        return s.empty();
    }
    if (p.length() > 1 && p[1] == '*') {
        if (isMatch(s, p.substr(2))) {
            return true;
        } else if (s.length() > 0 && (p[0] == '.' || p[0] == s[0])) {
            return isMatch(s.substr(1), p);
        }
    } else if (s.length() > 0 && (p[0] == '.' || p[0] == s[0])) {
        return isMatch(s.substr(1), p.substr(1));
    }
    return false;
}

除了递归做法外，这道题还有DP的做法，设dp[i][j]是字符串s,p的子串s[0,i]和p[0,j]是否匹配，可以得到相应的状态转换方程。不过DP方法比较难懂，状态转换方程较为复杂，这里我就不说啥了，毕竟虽然能看懂，但自己想出来是不可能的。

bool isMatch(string s, string p) {
    vector<vector<bool> > dp(s.size() + 1, vector<bool>(p.size() + 1, false));
    int m = s.length(), n = p.length();
    dp[0][0] = true;
    for (int i = 1; i <= n; i++) {
        dp[0][i] = i > 1 && p[i-1] == '*' && dp[0][i-2];
    }
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (p[j-1] == '*') {
                dp[i][j] = dp[i][j-2] || ((p[j-2] == s[i-1] || p[j-2] == '.') && dp[i-1][j]);
            } else {
                dp[i][j] = dp[i-1][j-1] && (p[j-1] == '.' || p[j-1] == s[i-1]);
            }
        }
    }
    return dp[m][n];
}

11. Container with Most Water

Q: Given n non-negative integers a1, a2, …, an , where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of the line i is at (i, ai) and (i, 0). Find two lines, which, together with the x-axis forms a container, such that the container contains the most water.

Notice that you may not slant the container.

这个题可以用o(n^2)的笨办法做出来，勉强不会超时，但同时这个题也有o(n)的方法，其思路是：一个容器的容量为 $min (𝑎_{𝑖}, 𝑎_{𝑗}) \times ABS (𝑖 - 𝑗)$ ，那么我们可以先从ABS(i - j)最大，即i=1,j=n时开始，逐步向中心遍历，因为乘法的一个乘数只会逐渐变小，那么另一个乘数必须变大，才能让我们的结果尽可能大。同时由于木桶的短板原理，即使我们将更高的一块木板变得更高，容量也不会变得更大。因此我们必须从更短的那一侧逐渐向内搜索，才有可能得到更大的容量。也就是说，通过这些前提条件，我们可以这样对搜索范围进行剪枝，完全略过那些不存在答案的搜索空间。

int maxArea(vector<int>& height) {
    int n = height.size(), l = 0, r = n - 1, res = 0;
    while (l < r) {
        res = max(res, min(height[l], height[r]) * (r - l));
        // 必须从较短的木板朝中心靠拢，才有可能得到更大的res
        if (height[l] < height[r]) {
            l++;
        } else {
            r--;
        }
    }
    return res;
}

12. Integer to Roman

Q: Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.

Symbol       Value
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

For example, 2 is written as II in Roman numeral, just two one’s added together. 12 is written as XII, which is simply X + II. The number 27 is written as XXVII, which is XX + V + II.

Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:

I can be placed before V (5) and X (10) to make 4 and 9. X can be placed before L (50) and C (100) to make 40 and 90. C can be placed before D (500) and M (1000) to make 400 and 900. Given an integer, convert it to a roman numeral.

将一个整数转换为罗马数字的形式，爷吐了。

string intToRoman(int num) {
    int digit;
    string res, tmp;
    string digits = "IVXLCDM ";
    for (int i = 0; num; i++) {
        digit = num % 10;
        tmp = "";
        if (digit == 9) {
            tmp = digits.substr(2 * i, 1) + digits.substr(2 * i + 2, 1);
        } else if (digit == 4) {
            tmp = digits.substr(2 * i, 2);
        } else {
            if (digit > 4) {
                digit -= 5;
                tmp += digits.substr(2 * i + 1, 1);
            }
            while (digit--) {
                tmp += digits.substr(2 * i, 1);
            }
        }
        res = tmp + res;
        num /= 10;
    }
    return res;
}

13. Roman to Integer

Q: Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.

Symbol       Value
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

For example, 2 is written as II in Roman numeral, just two one’s added together. 12 is written as XII, which is simply X + II. The number 27 is written as XXVII, which is XX + V + II.

I can be placed before V (5) and X (10) to make 4 and 9. X can be placed before L (50) and C (100) to make 40 and 90. C can be placed before D (500) and M (1000) to make 400 and 900. Given a roman numeral, convert it to an integer.

将一个罗马数字转换为普通的整数，相比上一题，这一题还是简单不少。

 int romanToInt(string s) {
     int ans = 0;
     char pc = 0;
     int val[256] = {0};
     val['M'] = 1000;
     val['D'] = 500;
     val['C'] = 100;
     val['L'] = 50;
     val['X'] = 10;
     val['V'] = 5;
     val['I'] = 1;
     for (auto& c : s) {
         if (val[pc] < val[c]) {
             ans += val[c] - (val[pc] << 1);
         } else {
             ans += val[c];
         }
         pc = c;
     }
     return ans;
 }

14. Longest Common Prefix

Q: Write a function to find the longest common prefix string amongst an array of strings.

If there is no common prefix, return an empty string ““.

这题其实比较简单，关键在于需要考虑很多细节。我个人写的不太简洁，这里贴一段别人写的比较简洁的代码。

string longestCommonPrefix(vector<string>& strs) {
    string prefix = "";
    for (int idx = 0; strs.size() > 0; prefix += strs[0][idx], idx++) {
        for (int i = 0; i < strs.size(); i++) {
            if (idx >= strs[i].size() || (i > 0 && strs[i][idx] != strs[i - 1][idx])) {
                return prefix;
            }
        }
    }
    return prefix;
}

17. Letter Combinations of a Phone Number

Q: Given a string containing digits from 2-9 inclusive, return all possible letter combinations that the number could represent. Return the answer in any order.

这个题也没啥好说的，我也是第一思路递归，把当前数字键上的字母和余下数字序列的所有答案组合起来。队列做法相对巧妙一些，也稍微难写一些，但也没有太大难度。

// 递归写法
vector<string> letterCombinations(string digits) {
    vector<string> ans;
    vector<string> map{"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
    if (digits.empty()) {
        return {};
    } else if (digits.length() == 1) {
        for (int i = 0; i < map[digits[0] - '2'].length(); i++) {
            ans.push_back(map[digits[0] - '2'].substr(i, 1));
        }
        return ans;
    } else {
        for (int i = 0; i < map[digits[0] - '2'].length(); i++) {
            for (auto& s : letterCombinations(digits.substr(1))) {
                ans.push_back(map[digits[0] - '2'][i] + s);
            }
        }
        return ans;
    }
}

// 队列写法
vector<string> letterCombinations(string digits) {
    vector<string> ans;
    vector<string> map{"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
    queue<string> q;
    q.push("");
    string tmp;
    while (!q.empty()) {
        tmp = q.front();
        q.pop();
        if (tmp.length() == digits.length()) {
            if (tmp.length() != 0) {
                ans.push_back(tmp);
            }
        } else {
            for (int i = 0; i < map[digits[tmp.length()] - '2'].length(); i++) {
                q.push(tmp + map[digits[tmp.length()] - '2'].substr(i, 1));
            }
        }
    }
    return ans;
}

20. Valid Parentheses

Q: Given a string s containing just the characters ‘(‘, ‘)’, ‘{‘, ‘}’, ‘[‘ and ‘]’, determine if the input string is valid.

An input string is valid if:

Open brackets must be closed by the same type of brackets.
Open brackets must be closed in the correct order.

使用栈来处理即可，左括号推入栈。右括号则检查栈顶是否有匹配的左括号。没有即不匹配，有则将其推出栈即可。所有字符遍历过后，如果栈内不为空，则说明，有部分左括号没有匹配的右括号。如果为空，则说明所有的括号都是匹配的。

bool isMatchChar(char c1, char c2) {
    return c1 == '[' && c2 == ']' || c1 == '(' && c2 == ')' || c1 == '{' && c2 == '}';
}

bool isValid(string s) {
    stack<char> stk;
    for (auto& c : s) {
        if (c == ']' || c == '}' || c == ')') {
            if (stk.empty() || !isMatchChar(stk.top(), c)) {
                return false;
            }
            stk.pop();
        } else {
            stk.push(c);
        }
    }
    return stk.empty();
}

21. Merge Two Sorted Lists

Q: Merge two sorted linked lists and return it as a sorted list. The list should be made by splicing together the nodes of the first two lists.

将两个有序的链表合并，这个题我是选择递归做法的，相对来说比较简单，我们只需要选出两个头节点里最小的那个，然后将剩下的两个链表递归的合并，再将合并好的链表接到最小的头节点后面即可。相对来说，非递归的写法还是比较难写的。

/*
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    if (!l1) { return l2; }
    if (!l2) { return l1; }
    ListNode* minNode = l1->val < l2->val ? l1 : l2;
    ListNode* maxNode = l1->val < l2->val ? l2 : l1;
    minNode->next = mergeTwoLists(minNode->next, maxNode);
    return minNode;
}

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    ListNode dummy(0), *tail = &dummy;
    while (l1 && l2) {
        if (l1->val < l2->val) {
            tail->next = l1;
            l1 = l1->next;
        } else {
            tail->next = l2;
            l2 = l2->next;
        }
        tail = tail->next;
    }
    // we have to connect the rest part to the returned linked list
    tail->next = l1 ? l1 : l2;
    return dummy.next;
}

22. Generate Parentheses

Q: Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.

给出括号的对数，生成所有合法的包含指定对数括号的字符串，第一反应是递归，对于n的case，我们生成i和n-i的所有case，然后将他们两两组合起来，同时再生成n-1的case，再将他们包在一对括号里。但是这样做需要去除相同的项。即如下

vector<string> generateParenthesis(int n) {
    vector<string> ans;
    if (n == 0) {
        ans = {};
    }
    else if (n == 1) {
        ans = {"()"};
    } else {
        for (int i = 1; i < n; i++) {
            for (auto& s1 : generateParenthesis(i)) {
                for (auto& s2 : generateParenthesis(n - i)) {
                    ans.push_back(s1 + s2);
                }
            }
        }
        for (auto& s : generateParenthesis(n - 1)) {
            ans.push_back("(" + s + ")");
        }
        set<string> ss(ans.begin(), ans.end());
        ans.clear();
        for (auto& s : ss) {
            ans.push_back(s);
        }
    }
    return ans;
}

当然这个题有另外一种更加巧妙的递归方式，我们把问题分为3部分，case(1)/case(i)/case(n-i-1)，然后我们进行这样的组合，"(" + case(i) + ")" + case(n-i-1)，基础的case当然是case(0)返回包含一个空字符串的集合。这种递归方式得到的解是没有重复和遗漏的。我们先看代码：

vector<string> generateParenthesis(int n) {
    vector<string> ans;
    if (n == 0) {
        return { "" };
    }
    for (int i = 0; i < n; i++) {
        for (auto& s1 : generateParenthesis(i)) {
            for (auto& s2 : generateParenthesis(n - i - 1)) {
                ans.push_back("(" + s1 + ")" + s2);
            }
        }
    }
    return ans;
}

为什么这样可以做到不重不漏呢，我们先来看相对比较明显的不重复性。假设ANS(n)是n对应的所有字符串的集合，以下均假设n>0。对于两个不同的答案来说，要相等即意味着字符串所有位置均相等，对于以上代码来说，就是要每次push_back答案字符串进入ans时，都要保证s1和s2至少有一个和其他的答案不同，也就是说ANS(i)和ANS(n-i-1)内没有重复元素。即只要保证对于[0, n-1]区间内的所有k来说来说，ANS(k)都不包含重复元素，则ANS(n)也不包含重复元素。这个我们可以通过数学归纳法比较简单的得到保证，不再赘述。

再看没有遗漏，没有遗漏意味着所有答案都是符合"(" + case(i) + ")" + case(n-i-1)这样的形式的，同时所有这样形式的字符串都是答案。后者是显然的，因为这样的字符串显然是合法的。我们知道合法的字符串第一个字符肯定是左括号，而且在字符串中有唯一一个与之匹配的右括号，且我们可以肯定，被这两个括号括起来的字符串肯定也是合法的，否则的话整个字符串也是不合法的。同样，右侧不包含在括号之内的字符串也是合法的。因此整个字符串肯定可以写成"(" + case(i) + ")" + case(n-i-1)的形式，其中，case(n-i-1)和case(i)均有可能为空。

最后通过双重循环，我们的答案包含了所有形如"(" + case(i) + ")" + case(n-i-1)的字符串，即保证了返回值里所有的字符串均是合法的答案，且没有重复的答案。

Leetcode刷题笔记 2

2021-06-20T00:00:00Z

本周Leetcode刷题笔记

345. Reverse Vowels of a String

Q: Given a string s, reverse only all the vowels in the string and return it.

The vowels are 'a', 'e', 'i', 'o', and 'u', and they can appear in both cases.

从两边向中间遍历，都碰到元音之后就交换继续遍历即可。

bool isVowels(char c) {
    c = tolower(c);
    return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}

string reverseVowels(string s) {
    int l = 0, r = s.length() - 1;
    while (l < r) {
        while (l < r && !isVowels(s[l])) l++;
        while (l < r && !isVowels(s[r])) r--;
        swap(s[l++], s[r--]);
    }
    return s;
}

1091. Shortest Path in Binary Matrix

Q: Given an n x n binary matrix grid, return the length of the shortest clear path in the matrix. If there is no clear path, return -1.

A clear path in a binary matrix is a path from the top-left cell (i.e., (0, 0)) to the bottom-right cell (i.e., (n - 1, n - 1)) such that:

All the visited cells of the path are 0. All the adjacent cells of the path are 8-directionally connected (i.e., they are different and they share an edge or a corner). The length of a clear path is the number of visited cells of this path.

这个题可以简单的使用BFS做，也可以考虑寻路算法，我第一想法是寻路，就糊了一个简单的实现。

int shortestPathBinaryMatrix(vector<vector<int>>& grid) {
    int n = grid.size();
    priority_queue<pair<int, pair<int, int>>, vector<pair<int, pair<int, int>>>, greater<pair<int, pair<int, int>>>> oq;
    set<pair<int, int>> open, close;
    vector<pair<int, int>> direction{ {1, 1}, {1, 0}, {0, 1}, {-1, 1}, {1, -1}, {0, -1}, {-1, 0}, {-1, -1} };
    if (grid[0][0] == 0) {
        oq.emplace(1, pair<int, int>{0, 0});
        open.emplace(0, 0);
    }
    while (!oq.empty()) {
        auto [v, pos] = oq.top();
        auto &[a, b] = pos;
        oq.pop();
        open.erase(pos);
        if (a == n - 1 && b == n - 1) {
            return v;
        }
        if (close.find(pos) == close.end()) {
            close.insert(pos);
            for (auto &[i, j] : direction) {
                int x = a + i, y = b + j;
                if (0 <= x && x < n && 0 <= y && y < n && grid[x][y] == 0 && close.find({x, y}) == close.end()  && open.find({x, y}) == open.end()) {
                    open.emplace(x, y);
                    oq.emplace(v + 1, pair<int, int>{x, y});
                }
            }
        }
    }
    return -1;
}

下面是一份别人实现的BFS，用两个队列依次遍历的做法我好像还是第一次见，感觉不明觉厉。

int shortestPathBinaryMatrix(vector<vector<int>>& g, int steps = 0) {
    int n = g.size();
    queue<pair<int, int>> q;
    vector<pair<int, int>> direction{ {1, 1},{0, 1},{1, 0},{-1, 1},{1, -1},{0, -1},{-1, 0},{-1, -1} };
    q.emplace(0, 0); // we won't return steps if g[0][0] == 1, so we just push {0, 0} here
    while (!q.empty()) {
        steps++;
        queue<pair<int, int>> q1;
        // for every pos we can reach
        while (!q.empty()) {
            auto [x, y] = q.front();
            q.pop();
            // mark pos as visited
            if (exchange(g[x][y], 1) == 1) {
                continue;
            }
            if (x == n - 1 && y == n - 1) {
                return steps;
            }
            for (auto &[i, j] : direction) {
                int r = x + i, t = y + j;
                if (0 <= r && r < n && 0 <= t && t < n && !g[r][t]) {
                    q1.emplace(r, t);
                }
            }
        }
        // swap queues means we take a extra step
        swap(q, q1);
    }
    return -1;
}

740. Delete and Earn

Q: Given an array nums of integers, you can perform operations on the array.

In each operation, you pick any nums[i] and delete it to earn nums[i] points. After, you must delete every element equal to nums[i] - 1 or nums[i] + 1.

You start with 0 points. Return the maximum number of points you can earn by applying such operations.

从数组中选择一个数n，可以获得对应的n分，但是必须删除所有等于n-1和n+1的数，如果有多个数n，可以获得多个n的分数。求最多可以获得多少分。第一反应我们可以统计不同的数值对应多少分数，然后可以对不同的值进行动态规划。不过我写出来的还是有点繁琐。这里我是先用哈希表存储在将数据移动到vector里，排序再做的，而实际上由于这里数字的范围并不算大，因此可以直接保存到一个大数组内，也不需要排序。

int deleteAndEarn(vector<int>& nums) {
    unordered_map<int, int> cnt, dp;
    for (const auto &n : nums) {
        cnt[n] += n;
    }
    vector<pair<int, int>> vec{cnt.begin(), cnt.end()};
    sort(vec.begin(), vec.end());
    int lastk = 0, sk = 0;
    for (const auto &[k, v] : vec) {
        if (lastk + 1 < k) {
            dp[k] = dp[lastk] + v;
        } else {
            dp[k] = max(dp[lastk], dp[sk] + v);
        }
        sk = lastk;
        lastk = k;
    }
    int res = 0;
    for (const auto & [k, v] : dp) {
        res = max(res, v);
    }
    return res;
}

可以看到别人的做法可以说是简洁多了，对于每一个数字，我们都有take和skip两种选择，问题的限制是如果当前数字选择take，下一个数字就必须skip，这里是状态机的思想去思考，对于每一步，我们都基于上一步的两个最优状态来进行决策，从而更新当前步骤的状态。

int deleteAndEarn(vector<int> &nums) {
    vector<int> values(10001, 0);
    for (const auto &n : nums) {
        values[n] += n;
    }
    int take = 0, skip = 0;
    for (int i = 0; i < 10001; i++) {
        int tmp = max(skip + values[i], take);
        skip = take;
        take = tmp;
    }
    return take;
}

1665. Minimum Initial Energy to Finish Tasks

Q: You are given an array tasks where tasks[i] = [actual_i, minimum_i]:

actual_i is the actual amount of energy you spend to finish the $𝑖_{𝑡 ℎ}$ task.
minimum_i is the minimum amount of energy you require to begin the $𝑖_{𝑡 ℎ}$ task.

For example, if the task is [10, 12] and your current energy is 11, you cannot start this task. However, if your current energy is 13, you can complete this task, and your energy will be 3 after finishing it.

You can finish the tasks in any order you like.

Return the minimum initial amount of energy you will need to finish all the tasks.

这个问题也挺tricky的，每个任务都有最小要求和实际要求，你可以以任意顺序执行任务，求能完成所有任务的初始能量的最小值。提示实际上有点坑爹，因为提示1说我们可以轻易的求出x是否满足要求，因此我们可以用二分法做。实际上我并没有看出这里的轻易。

当时我猜测应该是可以用<minimum - actual>对任务排序，这样的策略是最优的，但是并没有证明。而且如果这样的策略是最优的话，我们根本不需要用二分法做，只需要倒推就可以得到结果了。

根据别人的解答，我们可以这样理解这个问题，同样是倒推的思维。

假设你是一家公司的总裁，现在你们公司有n个投资者，每个投资者都有一个门槛<minimum - actual>和一个实际的投资额actual，公司的市值需要达到投资者的最低门槛，投资者才会实际投资，而你的目标是获得所有投资者的投资。当公司的市值达不到一个投资者的要求时，你可以自掏腰包来提升公司的市值，但显然你希望你自己投入的越少越好。因此，你将这些投资者按照各自的门槛排序，从最低门槛的投资者开始，如果不够，就自己补足到符合他的门槛。直到公司获得所有的投资。因为每获得一笔投资，公司的市值都会增加，因此这样是最优策略。而最终公司的市值，就对应题目的答案，即能完成所有任务的最小初始能量。

现在从正向来考虑这个问题，对于所有的任务来说，完成这些任务所需要的实际能量是固定的，因此要求最小初始能量实质上就是要求最终剩余能量最小。在公司的例子里，这就对应着你自己的投入。

最后，我当时猜出的代码结果正确，但是一直超时，看样例才知道有组样例的task都是[1, 10000]，可能因此影响了排序算法的效率，换成stable_sort才勉强通过。

int minimumEffort(vector<vector<int>>& tasks) {
    // 按照门槛排序，门槛相同时，实际投资额无所谓
    stable_sort(tasks.begin(), tasks.end(), [](auto v1, auto v2) { return v1[1] - v1[0] < v2[1] - v2[0]; });
    int res = 0;
    for (const auto &vec : tasks) {
        // 逆推，如果小于门槛则自己补足至门槛
        int actual = vec[0], minimum = vec[1];
        res = max(res + actual, minimum);
    }
    return res;
}

801. Minimum Swaps to Make Sequences Increasing

Q: We have two integer sequences nums1 and nums2 of the same non-zero length.

We are allowed to swap elements nums1[i] and nums2[i]. Note that both elements are in the same index position in their respective sequences.

At the end of some number of swaps, nums1 and nums2 are both strictly increasing. (An array A is strictly increasing if and only if A[0] < A[1] < A[2] < ... < A[A.length - 1].)

Given nums1 and nums2, return the minimum number of swaps to make both sequences strictly increasing. It is guaranteed that the given input always makes it possible.

这个题看起来也挺懵的，思考了一阵之后觉得可以用DP，可以用两个状态表示，比如说dp0[i]表示第i位不交换的情况下最小的交换次数，而dp1[i]表示第i位交换的情况下最小的交换次数，初始状态也简单，dp0[0] = 0, dp1[0] = 1; 接下来可以分类讨论:

如果nums1[i-1] < nums1[i] && nums2[i-1] < nums2[i] && nums1[i-1] < nums2[i] && nums2[i-1] < nums1[i]，那么i-1和i这两位无论交换与否，都满足严格递增的条件，因此：

dp1[i] = min(dp0[i - 1], dp1[i - 1]) + 1;
dp0[i] = min(dp0[i - 1], dp1[i - 1]);

如果只满足nums1[i-1] < nums1[i] && nums2[i-1] < nums2[i]，则说明i-1和i要么都交换，要么都不交换，才能满足严格单调递增的条件，因此：

dp1[i] = dp1[i - 1] + 1;
dp0[i] = dp0[i - 1];

如果只满足nums1[i-1] < nums2[i] && nums2[i-1] < nums1[i]则与情况2相反，i-1和i这两位只能恰好有1位交换，才能满足严格单调递增的条件，因此：

dp1[i] = dp0[i - 1] + 1;
dp0[i] = dp1[i - 1];

理清了这些关系，代码就好写了，同时可以注意到我们并不需要一个数组来存储dp的结果，每一步的结果，都只依赖于上一步的结果，因此可以这样

int minSwap(vector<int>& nums1, vector<int>& nums2) {
    int n = nums1.size();
    int swap = 1, skip = 0;
    for (int i = 1; i < n; i++) {
        int preSwap = swap, preSkip = skip;
        if (nums1[i-1] < nums1[i] && nums2[i-1] < nums2[i] && nums1[i-1] < nums2[i] && nums2[i-1] < nums1[i]) {
            swap = min(preSkip, preSwap) + 1;
            skip = min(preSkip, preSwap);
        } else if (nums1[i-1] < nums1[i] && nums2[i-1] < nums2[i]) {
            swap = preSwap + 1;
            skip = preSkip;
        } else {
            swap = preSkip + 1;
            skip = preSwap;
        }
    }
    return min(skip, swap);
}

89. Gray Code

Q: An n-bit gray code sequence is a sequence of $2^{𝑛}$ integers where:

Every integer is in the inclusive range $[0, 2^{𝑛} - 1]$ ,
The first integer is 0,
An integer appears no more than once in the sequence,
The binary representation of every pair of adjacent integers differs by exactly one bit, and
The binary representation of the first and last integers differs by exactly one bit.

Given an integer n, return any valid n-bit gray code sequence.

初看也有点懵，关键是相邻的数之间只能有一个位不同，而且必须包含 $[0, 2^{𝑛} - 1]$ 之间所有的整数。

不过很快意识到这个题可以用递归做，如果我有一组n=i时的数组，那么我只需要先遍历一次这个数组，然后将i+1位取反再遍历一次即可得到n=i+1时对应的数组。而且这里可以比较简单的写成循环的形式。

vector<int> grayCode(int n) {
    vector<int> res(1 << n, 0);
    for (int i = 0, k = 1; i < n; i++) {
        for (int j = 0; j < k; j++) {
            res[k + j] = res[k - j - 1] | k;
        }
        k = k << 1;
    }
    return res;
}

看讨论时，看到了另一种简单的做法如下，也就是 f(x) = x ^ (x >> 1)，具体就不证明了。

vector<int> grayCode(int n) {
    vector<int> res(1 << n, 0);
    for (int i = 0; i < (1 << n); i++) {
        res[i] = i ^ (i >> 1);
    }
    return res;
}

1513. Number of Substring with only 1s

Q: Given a binary string s (a string consisting only of '0' and '1's).

Return the number of substrings with all characters 1′s.

Since the answer may be too large, return it modulo $10^{9} + 7$ .

这个题目相对比较简单，可以想到，每“组”相邻的n个1，都可以增加 $\frac{𝑛 \times (𝑛 + 1)}{2}$ 个合理的子串。实际写的时候，可以写成这样比较简洁的形式。

int numSub(string s) {
    int res = 0, count = 0;
    for (const auto c : s) {
        count = c == '1' ? count + 1 : 0;
        res = (res + count) % 1000000007;
    }
    return res;
}

接下来是这周的周赛，我做出来三个，只能说这周相对比较简单吧，其实回头看第四题也不算难，不过缺少经验，确实比较难做出来。

1903. Largest Odd Number in String

Q: You are given a string num, representing a large integer. Return the largest-valued odd integer (as a string) that is a non-empty substring of num, or an empty string “” if no odd integer exists.

A substring is a contiguous sequence of characters within a string.

翻译：找出字符串的最后一个奇数字符

string largestOddNumber(string num) {
    int i;
    for (i = num.length() - 1; i >= 0; i--) {
        if ((num[i] - '0') % 2 == 1) {
            break;
        }
    }
    return num.substr(0, i + 1);
}

1904. The Number of Full Rounds You Have Played

Q: A new online video game has been released, and in this video game, there are 15-minute rounds scheduled every quarter-hour period. This means that at HH:00, HH:15, HH:30 and HH:45, a new round starts, where HH represents an integer number from 00 to 23. A 24-hour clock is used, so the earliest time in the day is 00:00 and the latest is 23:59.

Given two strings startTime and finishTime in the format “HH:MM” representing the exact time you started and finished playing the game, respectively, calculate the number of full rounds that you played during your game session.

For example, if startTime = “05:20” and finishTime = “05:59” this means you played only one full round from 05:30 to 05:45. You did not play the full round from 05:15 to 05:30 because you started after the round began, and you did not play the full round from 05:45 to 06:00 because you stopped before the round ended. If finishTime is earlier than startTime, this means you have played overnight (from startTime to the midnight and from midnight to finishTime).

Return the number of full rounds that you have played if you had started playing at startTime and finished at finishTime.

也不难，问特定时间段内有多少个整刻，刻应该是表示15分钟吧。anyway：

int numberOfRounds(string startTime, string finishTime) {
    int sh = atoi(startTime.substr(0, 2).c_str()), sm = atoi(startTime.substr(3).c_str());
    int fh = atoi(finishTime.substr(0, 2).c_str()), fm = atoi(finishTime.substr(3).c_str());
    if (sh > fh || (sh == fh && sm > fm)) {
        fh += 24;
    }
    return (fh - sh) * 4 + fm / 15 - (sm + 14) / 15;
}

2021-6-22 update: 这道题有一点问题，当起始时间和终止时间再同一个刻里的时候，比如00:01->00:10，代码会输出-1，因此上面的代码需要返回原本结果和0的最大值。即

return (fh - sh) * 4 + max(0, fm / 15 - (sm + 14) / 15);

但比赛时的数据没有出现这个特殊样例，因此比赛时这样写的人都通过了，然而过后应该是重新计分了，呜呜呜，也就是说我只做对了2题。今天我一看leetcode还以为自己出现幻觉了，呜呜呜。

1905. Count Sub Islands

Q: You are given two m x n binary matrices grid1 and grid2 containing only 0′s (representing water) and 1′s (representing land). An island is a group of 1′s connected 4-directionally (horizontal or vertical). Any cells outside of the grid are considered water cells.

An island in grid2 is considered a sub-island if there is an island in grid1 that contains all the cells that make up this island in grid2.

Return the number of islands in grid2 that are considered sub-islands.

也不算难，就是写起来有点烦，我当时有点懵，写的比较复杂，实际上完全没有必要向我这样先把island的坐标提取出来再判断，边提取坐标边DFS判断应该也是ok的，只能说，能过就行。

void helper(vector<vector<int>>& grid, vector<pair<int, int>>& island, int x, int y) {
    int direction[4][2] = { {-1, 0}, {0, -1}, {0, 1}, {1, 0} };
    if (0 <= x && x < grid.size() && 0 <= y && y < grid[0].size() && grid[x][y] == 1) {
        grid[x][y] = 0;
        island.emplace_back(x, y);
        for (auto &[m, n] : direction) {
            helper(grid, island, x + m, y + n);
        }
    }
}

vector<vector<pair<int, int>>> getIslands(vector<vector<int>>& grid) {
    vector<vector<pair<int, int>>> ans;

    int count = -1;
    for (int i = 0; i < grid.size(); i++) {
        for (int j = 0; j < grid[i].size(); j++) {
            if (grid[i][j] == 1) {
                vector<pair<int, int>> island;
                helper(grid, island, i, j);
                ans.push_back(island);
            }
        }
    }
    return ans;
}

int countSubIslands(vector<vector<int>>& grid1, vector<vector<int>>& grid2) {
    int count = 0;
    for (auto &vec : getIslands(grid2)) {
        bool flag = true;
        for (const auto &[x, y] : vec) {
            flag &= grid1[x][y];
        }
        count += flag;
    }
    return count;
}

1906. Minimum Absolute Difference Queries

Q: The minimum absolute difference of an array a is defined as the minimum value of |a[i] - a[j]|, where 0 <= i < j < a.length and a[i] != a[j]. If all elements of a are the same, the minimum absolute difference is −1.

For example, the minimum absolute difference of the array [5,2,3,7,2] is |2 - 3| = 1. Note that it is not 0 because a[i] and a[j] must be different.

You are given an integer array nums and the array queries where queries[i] = [li, ri]. For each query i, compute the minimum absolute difference of the subarray nums[li…ri] containing the elements of nums between the 0-based indices li and ri (inclusive).

Return an array ans where ans[i] is the answer to the ith query.

A subarray is a contiguous sequence of elements in an array.

The value of |x| is defined as:

x if x >= 0.
-x if x < 0.

应该是我参加以来第一道不是hard的压轴题了，难度也是Medium，可惜我当时没有很好的思路，我当时的思路是DP把所有子串的结果都求出来，然而日常超时。实际上因为题目限制数值范围在1-100之间，因此，我们可以一个数组count[n][k]统计每个数字出现的次数，即count[i][k]表示[0...i]之间k出现的次数，因此我们可以更容易的获取[i...j]之间各个数字出现的次数，然后求出所有出现的数字的最小间隔即可。

vector<int> minDifference(vector<int>& nums, vector<vector<int>>& queries) {
    vector<vector<int>> preSum(nums.size() + 1, vector<int>(101, 0));
    vector<int> cnt(101), ans;
    for (int i = 1; i <= nums.size(); i++) {
        for (int j = 1; j < 101; j++) {
            preSum[i][j] = preSum[i - 1][j];
        }
        preSum[i][nums[i - 1]]++;
    }
    for (auto &vec : queries) {
        int l = vec[0], r = vec[1] + 1;
        for (int i = 1; i < 101; i++) {
            cnt[i] = preSum[r][i] - preSum[l][i];
        }
        int m = INT_MAX, pre = -1;
        for (int i = 0; i < 101; i++) {
            if (cnt[i] == 0) continue;
            if (pre != -1) m = min(m, abs(i - pre));
            pre = i;
        }
        ans.push_back(m == INT_MAX ? -1 : m);
    }
    return ans;
}

小结：总的来说这周的周赛还行吧，虽然比较简单，但毕竟我开始刷题参赛也不久，慢慢来吧，相比前几次也算是有一点点进步。

Leetcode刷题笔记 1

2021-06-19T00:00:00Z

1. Two Sum

Q: Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

第一反应自然是暴力

vector<int> twoSum(vector<int>& nums, int target) {
    vector<int> res;
    for (int i = 0; i < nums.size(); i++) {
        for (int j = i + 1; j < nums.size(); j++) {
            if (nums[i] + nums[j] == target) {
                return {i, j};
            }
        }
    }
    return {-1, -1};
}

但这样做显然不够好，我们可以使用键值对来存储<<value, index>>对，一边遍历一边查找键值对内是否有匹配的值。具体的数据结构可以选择哈希表，因为哈希表的插入/查找都是o(1)操作，因此我们可以将总体的复杂度降至o(n)

vector<int> twoSum(vector<int>& nums, int target) {
    vector<int> res;
    unordered_map<int, int> indices;
    for (auto it = nums.begin(); it != nums.end(); ++it) {
        if (indices.find(target - *it) != indices.end()) {
            res.push_back(indices[target - *it]);
            res.push_back(it - nums.begin());
            break;
        }
        indices[*it] = it - nums.begin();
    }
    return res;
}

2. Add Two Numbers

Q: You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

这个题不算难，就是写起来有点别扭，我自己写的非常丑，贴一个别人写的吧。

ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
    ListNode dummy(0), *p = &dummy;
    int carry = 0;
    while (l1 || l2 || carry) {
        int sum = (l1 ? l1->val : 0) + (l2 ? l2->val : 0) + carry;
        carry = sum / 10;
        p->next = new ListNode(sum % 10);
        p = p->next;
        l1 = l1 ? l1->next : l1;
        l2 = l2 ? l2->next : l2;
    }
    return dummy.next;
}

3. Longest Substring without Repeating Characters

Q: Given a string s, find the length of the longest substring without repeating characters.

简单的思路自然还是o(n^2)的，写起来也很简单

int lengthOfLongestSubstring(string s) {
    int ans = 0;
    for (int first = 0, last = 0; last < s.length(); last++) {
        for (int i = last - 1; i >= first; i--) {
            if (s[i] == s[last]) {
                first = i + 1;
                break;
            }
        }
        ans = max(res, last - first + 1);
    }
    return ans;
}

但是效率堪忧，容易想到保存字母最后出现的位置，在遍历的同时即可判断当前范围内是否有重复字符，因而只需要遍历一次即可解决，时间复杂度为o(n)，本题只有字母，因而使用数组就可以保存下标，如果碰到数字等范围较大的数据，则可以考虑哈希表，下面的代码是别人的实现，index数组里实际存储的不是最后出现的位置，而是最后出现的位置+1，每次遇到重复字符时，将first设置为该重复字符最后出现的位置+1，即可使范围内不再存在重复字符。只能说这个实现实在是非常精炼。

int lengthOfLongestSubstring(string s) {
    int ans = 0, index[256] = {0};
    for (int first = 0, last = 0; last < s.length(); last++) {
        first = max(index[s[last]], first);
        ans = max(ans, last - first + 1);
        index[s[last]] = last + 1; //index + 1, because index[] is init'd to all 0.
    }
    return ans;
}

5. Longest Palindrome Substring

Q: Given a string s, return the longest palindromic substring in s.

给一个字符串s，返回该字符串的最长回文子字符串。同样可以笨办法解决，思路也很简单，遍历所有可能的情况。对于每一个位置，都考虑奇数/偶数长度回文字符串向两个方向搜索，直到碰到不匹配的字符或者到达字符串边缘。

string longestPalindrome(string s) {
    int len = s.length(), max_len = 0, first = 0;
    for (int i = 0; i < len; i++) {
        //odd length
        for (int j = i, k = i; j < len && k >= 0 && s[j] == s[k]; j++, k--) {
            if (j - k + 1 > max_len) {
                max_len = j - k + 1;
                first = k;
            }
        }
        //even length
        for (int j = i + 1, k = i; j < len && k >= 0 && s[j] == s[k]; j++, k--) {
            if (j - k + 1 > max_len) {
                max_len = j - k + 1;
                first = k;
            }
        }
    }
    return s.substr(first, max_len);
}

这个问题有个o(n)的算法Manacher’s Algorithm，不过比较复杂，我就不献丑了。

6. ZigZag Conversion

Q: The string “PAYPALISHIRING” is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)

P   A   H   N
A P L S I I G
Y   I   R

And then read line by line: “PAHNAPLSIIGYIR”

Write the code that will take a string and make this conversion given a number of rows:

string convert(string s, int numRows);

这题要求实现一个字符串转换的函数，也是写起来比较烦的类型。总之我就不献丑了，抄了一个别人的代码。

string convert(string s, int numRows) {
    if (numRows == 1) return s;
    vector<string> rows(numRows);
    int curRow = 0, delta = -1;
    for (char c : s) {
        rows[curRow] += c;
        (curRow == 0 || curRow == numRows - 1) && (delta = -delta);
        curRow += delta;
    }
    string ret;
    for (string row : rows) {
        ret += row;
    }
    return ret;
}

7. Reverse Integer

Q: Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range $[- 2^{31}, 2^{31} - 1]$ , then return 0.

Assume the environment does not allow you to store 64-bit integers (signed or unsigned).

这是个有点意思也有点烦的题目，要求在不支持64位int的条件下实现翻转int的十进制位，如果可以使用64位整数，这个题目其实非常基础。

int reverse(int x) {
    long long res = x < 0 ? -1 : 1;
    long long sum = 0, tmp = labs(x);
    if (x == 0) return 0;
    while (tmp) {
        sum *= 10;
        sum += tmp % 10;
        tmp /= 10;
    }
    if (INT_MIN <= res * sum && res * sum <= INT_MAX)
        return res * sum;
    return 0;
}

如果限制64位数据，则需要仔细考虑溢出的问题，举个例子，一个8bit整数127翻转会变为721，原本不会溢出翻转之后就溢出了。本身这个题目就比较烦，主要考察的是底层的int范围，这里贴一个当时抄的代码。

int reverse(int x) {
    int rev = 0;
    while (x != 0) {
        int pop = x % 10;
        x /= 10;
        if (rev > INT_MAX/10 || (rev == INT_MAX / 10 && pop > 7)) return 0;
        if (rev < INT_MIN/10 || (rev == INT_MIN / 10 && pop < -8)) return 0;
        rev = rev * 10 + pop;
    }
    return rev;
}

8. String to Integer (atoi)

Q: Implement the myAtoi(string s) function, which converts a string to a 32-bit signed integer (similar to C/C++‘s atoi function).

The algorithm for myAtoi(string s) is as follows:

Read in and ignore any leading whitespace.
Check if the next character (if not already at the end of the string) is ‘-’ or ‘+’. Read this character in if it is either. This determines if the final result is negative or positive respectively. Assume the result is positive if neither is present.
Read in next the characters until the next non-digit charcter or the end of the input is reached. The rest of the string is ignored.
Convert these digits into an integer (i.e. “123” -> 123, “0032” -> 32). If no digits were read, then the integer is 0. Change the sign as necessary (from step 2).
If the integer is out of the 32-bit signed integer range $[- 2^{31}, 2^{31} - 1]$ , then clamp the integer so that it remains in the range. Specifically, integers less than $- 2^{31}$ should be clamped to $- 2^{31}$ , and integers greater than $2^{31} - 1$ should be clamped to $2^{31} - 1$ .
Return the integer as the final result.

Note:

Only the space character ‘ ‘ is considered a whitespace character.
Do not ignore any characters other than the leading whitespace or the rest of the string after the digits.

这题要求实现自己的atoi函数，比较麻烦，所以也不多说了，直接贴代码吧。

int myAtoi(string str) {
    int idx = 0, sign = 1, res = 0, tmp;
    while (str[idx] == ' ') { idx++; }
    if (str[idx] == '-' || str[idx] == '+') {
        if (str[idx] == '-') {
            sign = -1;
        }
        idx++;
    }
    if (!isdigit(str[idx])) { return 0; }
    while (isdigit(str[idx])) {
        tmp = str[idx] - '0';
        if (res > INT_MAX / 10) {
            return sign == 1 ? INT_MAX : INT_MIN;
        }
        if (res == INT_MAX / 10) {
            if (sign == 1 && tmp > 6) return INT_MAX;
            if (sign == -1 && tmp > 7) return INT_MIN;
        }
        res = res * 10 + tmp;
        idx++;
    }
    return sign * res;
}

20w46a潜影贝生成

2020-11-14T00:00:00Z

这个是我新开的一个系列，说是分析，其实就是简单的看下源码，比较仔细的了解一下游戏机制。之所以开这个坑，一是因为最近玩MC比较多，被MC独特的游戏方式所吸引，碰到很多问题比如刷铁机、刷怪塔、物品分类的时候，会很想深入研究里面的原理。而MC虽然并不是开源软件，但是多年来玩家对MC的解包反编译工作已经非常成熟，甚至官方还自己提供了用于反编译的mapping，因此只需要懂一点java，就可以深入了解游戏内的各种机制。二是因为最近刚刚宣布1.17版本，前几天出了第一个snapshot，其中有一个特性让我觉得有点怪，就是潜影贝在被其他潜影贝的子弹攻击后，有几率生成一只新的潜影贝。虽然我并不是要在MC里讲科学，但这个改动本身确实有点“不太合常理”，而且这一改动意味着将来玩家会有稳定的潜影盒获取途径，从而很大程度上影响玩家之后的游戏体验，可能会导致潜影盒“掉价”。当然我不觉得这是一件坏事，毕竟在末地到处找潜影贝的痛苦我还是感同身受的。从这一点上来说，潜影贝农场以后会是玩家必做农场，没有之一，什么女巫塔、凋零骷髅塔、刷铁机全都靠边站。当然我不是专业的java程序员，对java的了解仅限于能大概看懂代码而已，所以可能文章会有错漏，如果你发现了任何错漏，或者单纯的想和我在这方面交流，都欢迎与我联系。

多说几句，MC彻底的高自由度决定了，任何游戏机制或是特性、BUG，都会被玩家利用到极致，以刷铁机为例，本身是一种村民的保护机制，在检测到危险的时候主动召唤铁傀儡来保护村庄，但是因为铁傀儡死掉会掉落铁锭，从而导致这一机制几乎只是为了玩家刷铁锭而存在的。我对这一现象其实颇为不满，我认为要么官方不要提供这样会被玩家滥用的机制，要么官方能提供更加优雅的机制。当然这不是今天的重点，因此就不展开谈了，我之后还会针对刷铁机进行分析，到时候再讨论这个问题吧。

言归正传，我对比了20w46a和1.16.3的服务端代码中有关潜影贝的部分，这是他们的diff结果

diff 1.16.3/server/net/minecraft/world/entity/monster/Shulker.java 20w46a/server/net/minecraft/world/entity/monster/Shulker.java
41a42
> import net.minecraft.world.item.DyeColor;
46a48
> import net.minecraft.world.level.entity.EntityTypeTest;
72c74
<       this.targetSelector.addGoal(1, (new HurtByTargetGoal(this, new Class[0])).setAlertOthers());
---
>       this.targetSelector.addGoal(1, (new HurtByTargetGoal(this, new Class[]{this.getClass()})).setAlertOthers());
290c292
<             if (var3.getY() > 0 && this.level.isEmptyBlock(var3) && this.level.getWorldBorder().isWithinBounds(var3) && this.level.noCollision(this, new AABB(var3))) {
---
>             if (var3.getY() > this.level.getMinBuildHeight() && this.level.isEmptyBlock(var3) && this.level.getWorldBorder().isWithinBounds(var3) && this.level.noCollision(this, new AABB(var3))) {
292a295
>                   this.unRide();
305c308
<          return true;
---
>          return false;
336a340
>       Entity var3;
338c342
<          Entity var3 = var1.getDirectEntity();
---
>          var3 = var1.getDirectEntity();
344c348,350
<       if (super.hurt(var1, var2)) {
---
>       if (!super.hurt(var1, var2)) {
>          return false;
>       } else {
346a353,357
>          } else if (var1.isProjectile()) {
>             var3 = var1.getDirectEntity();
>             if (var3 != null && var3.getType() == EntityType.SHULKER_BULLET) {
>                this.hitByShulkerBullet();
>             }
350,351d360
<       } else {
<          return false;
358a368,386
>    private void hitByShulkerBullet() {
>       Vec3 var1 = this.position();
>       AABB var2 = this.getBoundingBox();
>       if (!this.isClosed() && this.teleportSomewhere()) {
>          int var3 = this.level.getEntities((EntityTypeTest)EntityType.SHULKER, var2.inflate(8.0D), Entity::isAlive).size();
>          float var4 = (float)(var3 - 1) / 5.0F;
>          if (this.level.random.nextFloat() >= var4) {
>             Shulker var5 = (Shulker)EntityType.SHULKER.create(this.level);
>             DyeColor var6 = this.getColor();
>             if (var6 != null) {
>                var5.setColor(var6);
>             }
>
>             var5.moveTo(var1);
>             this.level.addFreshEntity(var5);
>          }
>       }
>    }
>
410a439,448
>    }
>
>    public void setColor(DyeColor var1) {
>       this.entityData.set(DATA_COLOR_ID, (byte)var1.getId());
>    }
>
>    @Nullable
>    public DyeColor getColor() {
>       byte var1 = (Byte)this.entityData.get(DATA_COLOR_ID);
>       return var1 != 16 && var1 <= 15 ? DyeColor.byId(var1) : null;

我们主要关注的其实是其中的hitByShulkerBullet这个函数，那么先单独摘出来看看:

private void hitByShulkerBullet() {
    // 被击中的潜影贝所在位置
    Vec3 var1 = this.position();
    // 被击中的潜影贝所处的BoundingBox（边界框）
    AABB var2 = this.getBoundingBox();
    // 如果 潜影贝不处于关闭状态 并且 成功的传送走了
    if (!this.isClosed() && this.teleportSomewhere()) {
        // var3 代表当前潜影贝17x17x17范围内的潜影贝总数
        int var3 = this.level.getEntities((EntityTypeTest)EntityType.SHULKER, var2.inflate(8.0D), Entity::isAlive).size();
        // var4 是一个小数，根据潜影贝总数不同而不同，决定了潜影贝生成的几率，
        // 1 -> 100%
        // 2 -> 80%
        // 3 -> 60%
        // 4 -> 40%
        // 5 -> 20%
        // 6 -> 0%
        float var4 = (float)(var3 - 1) / 5.0F;
        // 此处即是决定潜影贝是否生成成功
        if (this.level.random.nextFloat() >= var4) {
            // 生成一个新的潜影贝
            Shulker var5 = (Shulker)EntityType.SHULKER.create(this.level);
            // 下面4行设定潜影贝的颜色
            DyeColor var6 = this.getColor();
            if (var6 != null) {
                var5.setColor(var6);
            }
            // 移动新潜影贝至原潜影贝的位置
            var5.moveTo(var1);
            // 将新潜影贝注册至当前level
            this.level.addFreshEntity(var5);
        }
    }
}

其实这里已经非常清楚了，但是还有一处相关的代码需要贴出来:

public boolean hurt(DamageSource var1, float var2) {
    // hurt 是一个用于处理伤害的函数，var1是施加伤害的实体，var2是伤害数值，最终如果伤害成功，则返回true，否则返回false
    Entity var3;
    if (this.isClosed()) {
        // 此处为潜影贝关闭时免疫箭矢伤害，和小黑类似
        var3 = var1.getDirectEntity();
        if (var3 instanceof AbstractArrow) {
            return false;
        }
    }

    if (!super.hurt(var1, var2)) {
        // 如果伤害施加不成功，则返回false，此时不会生成新潜影贝
        return false;
    } else {
        if ((double)this.getHealth() < (double)this.getMaxHealth() * 0.5D && this.random.nextInt(4) == 0) {
            // 成功施加伤害，且潜影贝生命值少于50%，此时有20%的几率潜影贝会直接传送走且不会生成新潜影贝
            this.teleportSomewhere();
        } else if (var1.isProjectile()) {
            var3 = var1.getDirectEntity();
            if (var3 != null && var3.getType() == EntityType.SHULKER_BULLET) {
                // 如果不满足上面的条件且施加伤害的实体是潜影贝的子弹，则会调用上面的函数
                this.hitByShulkerBullet();
            }
        }

        return true;
    }
}

之前说了，生成新潜影贝的条件之一是旧的潜影贝成功传送走，那么成功传送走的条件是什么呢？

protected boolean teleportSomewhere() {
    if (!this.isNoAi() && this.isAlive()) {
        // 当前位置
        BlockPos var1 = this.blockPosition();
        // 总共进行5次传送尝试
        for(int var2 = 0; var2 < 5; ++var2) {
            // 随机选取17x17x17范围内的一格
            BlockPos var3 = var1.offset(8 - this.random.nextInt(17), 8 - this.random.nextInt(17), 8 - this.random.nextInt(17));
            // 如果该位置大于最小建筑高度，且是空方块（空气方块），且不会有碰撞冲突问题
            if (var3.getY() > this.level.getMinBuildHeight() && this.level.isEmptyBlock(var3) && this.level.getWorldBorder().isWithinBounds(var3) && this.level.noCollision(this, new AABB(var3))) {
                // 在该位置上找一个可以附着的面
                Direction var4 = this.findAttachableFace(var3);
                if (var4 != null) {
                    // 如果成功找到，则首先尝试“下车”，再传送，设置朝向，播放传送音效登，仅有此时传送成功，返回true，其他情况均返回false
                    this.unRide();
                    this.entityData.set(DATA_ATTACH_FACE_ID, var4);
                    this.playSound(SoundEvents.SHULKER_TELEPORT, 1.0F, 1.0F);
                    this.entityData.set(DATA_ATTACH_POS_ID, Optional.of(var3));
                    this.entityData.set(DATA_PEEK_ID, (byte)0);
                    this.setTarget((LivingEntity)null);
                    return true;
                }
            }
        }

        return false;
    } else {
        return false;
    }
}

可以看到还是相当明白的，那么总结一下潜影贝的生成条件：

被潜影贝子弹击中，无论是该潜影贝自己发出的还是其他潜影贝发出的都可以
如果此时潜影贝生命值低于50%，则有20%机会直接传送走而不生成新潜影贝
处于打开状态，被潜影贝子弹击中，此时潜影贝会尝试传送走
成功传送走，条件比较复杂
如果满足了上述四个条件，则新潜影贝的生成机率和以潜影贝传送前位置为中心17x17x17范围内的潜影贝数量有关。用S代表潜影贝总数，其概率为

正常情况下S不会小于1，因为潜影贝只能传送到17x17x17范围内

理论上来说，生成效率主要取决于潜影贝的攻击频率，攻击频率越高，可能的效率就越高，类似ilmango的设计应该是相当高效的。总的来说，提高效率的思路无非是以下几点：

尽量快速清除生成的/传送走的潜影贝，最好使周围17x17x17范围内的仅存在一个潜影贝
尽量提高潜影贝成功传送的概率，需设计17x17x17范围内排布方式，假设该范围内有n个位置可传送，则传送成功的概率为 $𝑝 = 1 - {((17^{3} - 𝑛) / 17^{3})}^{5}$
尽量保持潜影贝的血量在50%以上，这条影响不是很大，如果不满足，大约会降低20%的效率
尽量使潜影贝子弹成功击中

其中，4是必须要想办法满足的前提，且比较复杂，不细说。能动性比较高的主要是1和2，如果能保持17x17x17范围内仅存在一个潜影贝，那么1就不会影响效率。而2，假设17x17x17范围内有100个位置可以传送，则每次传送成功的概率约为10%，而大约在636个位置的时候，传送成功率达到了50%，也就是说，如果其他条件都一样，那么636个位置的效率会是100个位置的效率的5倍。636个位置如果不管排布方式，则其实并不是很难，因为每个方块有6个面，则放106个建筑方块就满足条件了，实际情况中如ilmongo的设计采用的是单平面可传送，那么每个方块只有一个面可以传送，此时需要636个方块作为潜在的传送位置。也就是一片53x12的墙，或者近似做6块10x12的墙，这在17x17x17的范围内并不是什么难事。

下图展示了传送成功概率随可传送位置数量变化的曲线，可以看到，可传送位置越多，提升就越不明显，当概率高于0.8以上时，就明显不值得在这里付出精力了。而且范围内总共也就4913个方块，要在一定条件下满足这么多可传送位置并不容易。即使按照每个方块提供6个可传送位置来算，范围内最多可传送位置也仅有4200个。而实际上这是根本不可能做到的事情，因为还需要做处死或者转移潜影贝的装置。

Figure 4: 传送成功概率随可传送位置数量而变化的函数

在Vultr上安装Gentoo Linux

2020-04-03T00:00:00Z

最近Google/YouTuBe把我的vps的ip识别成了阿拉伯联合酋长国ip，结果就是推荐了一堆莫名其妙的视频/推送。总之，很不爽，我就决定在美国地区重新搞一个。由于Vultr支持vps附着一个自定义ISO文件来启动进入live环境，于是就可以用来安装Gentoo Linux。

基本的步骤可以在下面这个链接找到

Installing gentoo linux on a vultr server

最好是多参照官方安装文档：

Gentoo Handbook

安装好的Gentoo Linux VPS

Figure 5: neofetch

我只所以选择Gentoo Linux，主要还是因为其源代码分发带来的高度可定制性，举个例子，Gentoo可以让你用libressl替换openssl库，大部分二进制分发的发行版是做不到的。当然，这不代表这是个好选择或者是必要的选择。

gentoo的包管理总体来说还是相当不错的，比较好的特性主要有：

使用USE变量来选择需要的特性，比如说cmake可以有qt5的用户界面，也可以没有。
slot支持在同一个系统上安装统一软件的多个版本，比如python:2和python:3。
支持并行安装，同时进行多个安装
滚动更新，当然这个仁者见仁智者见智
包管理附带的各类工具非常齐全，比如equery,eselect,flaggie,repoman,genlop,etc-update等
打包很方便，基本只要有一些bash基础就可以自己打包，而且很多时候改一下版本号就可以适用于新版本了
文档丰富详细
很稳定，随便折腾都不会挂

缺点：

编译时间是真的长，尤其是桌面

当然这只是我个人的看法，肯定不客观

要安装gentoo之前，首先要做一些决定，比如

uefi/bios
openRC/systemd
multilib/nomultilib
分区方案
等等

我个人有点“洁癖”，不管是自己的笔记本还是服务器都选择了openRC和nomultilib的组合，甚至会在内核选项里关闭32位程序模拟。目前用下来是还没碰到大问题。总之这不代表这是一个好选择。

接下来我们就来说一下怎么安装gentoo，这里是在vultr上安装gentoo的步骤，所以并不代表适用其他情况。基本上这篇文章可以看作是上面链接的“翻译”，同时最好也看一边官方的安装文档。

注：命令里被<>扩起来的部分都需要整体替换为相应的内容

创建实例开启ssh服务

创建实例的时候选择custom iso，复制一个gentoo官方的最小化安装live链接，创建实例之后启动VNC窗口，由于VNC窗口不方便复制粘贴，因此推荐使用ssh远程安装，如果不介意，也可以直接用VNC窗口进行安装。建议使用passwd先修改root用户的密码。

启动ssh服务

/etc/init.d/sshd start
##passwd

启动之后就可以在本地使用ssh来进行远程安装了

ssh root@<server_ip>

分区

分区我使用了最简单的方案，2个分区，在自己的笔记本上，我是选择了复杂一点的方案，但也区别不大，主要是多了boot分区以及efi分区(UEFI启动)，以下是分区方案，依次是大小、设备名、挂载点

23GB /dev/vda1     /
2GB  /dev/vda2     swap

默认的磁盘设备是/dev/vda，这一步可以使用cfdisk或者parted或者其他工具进行，如

cfdisk /dev/vda

文件系统我选择了xfs，虽然ext4是Linux官方文件系统，但是需要保留少量额外的空间，所以。。。

mkfs.xfs /dev/vda1

创建并启用swap分区

mkswap /dev/vda2
swapon /dev/vda2

挂载主分区，把主系统的根目录挂载至live系统的/mnt/gentoo路径

mount /dev/vda1 /mnt/gentoo

安装基础系统

获取最新的stage3 tarball，stage3其实有不少不同的版本，如nomultilib，harden等等，需要选择相应的stage3文件，比如我选择纯64位环境，就要选择nomultilib的

cd /mnt/gentoo
wget <stage3_tarball_url>
tar xpfj <stage3_tarball_file> --xattrs

编辑主系统的/etc/portage/make.conf文件，当然在live系统里实际位置是在/mnt/gentoo/etc/portage/make.conf，配置好源，编译选项，这一部分最好参照官方安装文档。

配置portage的主仓库，即gentoo仓库，可以更改里面的sync-uri，以达到比较快的同步速度

mkdir -p /mnt/gentoo/etc/portage/repos.conf
cp /mnt/gentoo/usr/share/portage/config/repos.conf
/mnt/gentoo/etc/portage/repos.conf/gentoo.conf
# nano -w /mnt/gentoo/etc/portage/repos.conf/gentoo.conf

把live系统的DNS配置文件复制到主系统上，否则之后chroot到主系统后，无法解析域名，也就无法同步

cp -L /etc/resolv.conf /mnt/gentoo/etc/

挂载必要的文件系统，其中被注释的命令是使用systemd必须要执行的命令，如果使用openRC就无需执行

mount -t proc proc /mnt/gentoo/proc
mount --rbind /sys /mnt/gentoo/sys
# mount --make-rslave /mnt/gentoo/sys
mount --rbind /dev /mnt/gentoo/dev
# mount --make-rslave /mnt/gentoo/dev

chroot进入主系统

chroot /mnt/gentoo /bin/bash
export PS1="(chroot) $PS1"

获取portage树的快照

emerge-webrsync

读取portage的消息

eselect news list
eselect news read

选择profile，这里需要说一下，profile是gentoo提供的一种特性，不同的profile针对不同的使用环境/选择，会有不同的USE变量/默认的包等不同配置，比如kde桌面用户，就可以选择带plasma的profile，如果是systemd的用户，就可以选择带systemd的profile，切换profile是比较难的，因此这里需要谨慎选择。我们由于选择了nomultilib，因此这里也要选择nomultilib的profile

eselect profile list
eselect profile set <profile>

选择了profile之后就可以更新系统了，下面的选项a是ask，即需要自己确认是否执行操作，v是verbose，即详细信息，q是quiet，即减少输出，u是upgrade升级，D是指deep，是指检查依赖的更新，N是指new use，指如果一个包有新加的默认启用的USE变量，就重新编译这个包（？）。world是一个组，包含系统里的所有（？）包，这一步和内核编译都是耗时比较久的过程

emerge -avquDN @world

设置时区,area比如说Asia/Shanghai

echo "<area>" > /etc/timezone
emerge --config sys-libs/timezone-data

设置locale

nano /etc/locale.gen
locale-gen
eselect locale list
eselect locale set en_US.UTF-8

重新载入shell环境

env-update && source /etc/profile && export PS1="(chroot) $PS1"

安装Linux内核

安装Linux内核，这里我选择的gentoo官方内核

emerge -avq sys-kernel/gentoo-sources

安装完了之后，先切换至内核源文件目录，再进行配置，我用的单核VPS用genkernel工具编译太慢，就手动配置了，这一步也是最难的地方，总体来说一点一点手动配置内核实在是比较麻烦，我基本没怎么配置

cd /usr/src/linux
make menuconfig

配置内核方面，在VPS上，最主要要启用virtio系列的选项，主要有以下4个，当然最好关于virtio的选项都启用一下

CONFIG_VIRTIO_PCI
CONFIG_VIRTIO_MMIO
CONFIG_VIRTIO_BLK
CONFIG_VIRTIO_NET

另外就是文件系统，比如之前我使用了xfs的文件系统，那么就必须在内核配置里启用xfs文件系统支持，否则无法启动。

如果你需要使用docker之类的程序，那么还需要启用一些docker指定的选项，具体不表

配置完成之后就可以编译安装内核了。-j2指使用2个进程(还是线程？我不清楚)编译

make -j2 && make modules_install

安装内核镜像至/boot目录

make install

配置系统

编辑fstab文件，fstab文件是系统启动时自动挂载的配置，这里我们需要配置主分区和swap分区，具体请参照官方安装文档，推荐使用UUID区分不同的分区（上次被win10坑了）。

配置hostname，不赘述

配置网络，这里我目前也不是很懂，基本上照着做，大体上就是增加了一个启动项来处理网络连接

emerge -a --noreplace net-misc/netifrc

新建文件/etc/conf.d/net，写入

config_eth0="dhcp"

这里的eth0是你的网络设备名，vps上默认eth0，笔记本上自然不一样，笔记本上我选择了networkmanager，懒

网络启动项

cd /etc/init.d
ln -s net.lo net.eth0
rc-update add net.eth0 default

编辑hosts，不赘述

更改root用户密码

passwd

安装并启用一些系统工具

emerge -avq sysklogd logrotate cronie dhcpcd

rc-update add sshd default
rc-update add cronie default
rc-update add sysklogd default

安装grub:2，基本上bootloader大家都会选择grub2吧

emerge -avq sys-boot/grub:2

安装bootloader并生成开机选项

grub-install /dev/vda
grub-mkconfig -o /boot/grub/grub.cfg

建议新建普通用户，并加入wheel,portage等用户组，具体请参照官方安装文档

建议安装常用工具，配置好普通用户的sudo权限

emerge -avq dev-vcs/git sudo vim tmux gentoolkit eselect-repository strace lrzsz
nstats aria2 inxi htop lsof

建议配置好ssh登录选项

退出重启，移除ISO文件

exit
reboot

到这重启能正常启动、能连接网络，安装就成功了~

内脏暴击伤害计算测试

2019-10-26T00:00:00Z

在写这篇文章之前，我用了些时间做了关于血源内脏暴击伤害的一些测试，对于计算内脏暴击的伤害来说，得出了一些相对以往的测试来说更为准确的结论。在本文中，我主要介绍一些血源(或者说魂系列)的基础概念、说明基于这些事实如何设计这些测试、又如何处理测试得到的数据以及最后得到了什么样的结论。本文较长，假如没耐心看完，可以只看我给出的结论。

此外，本文的测试和结论基于某些以往的测试和结论以及攻略本，所以同样可能有不准确以及不完善之处。虽然我已经尽量排除这些因素，但不可避免会有疏漏，假如你发现了任何不准确之处或者单纯想交流一下，都可以与我联系。由于本人多少写过一点代码，所以本文里多少会有些代码，不过不理解的话其实也没有关系，忽略即可。

2020-11-14 update:

今天来更新这篇文章也是因为最近看到索尼在B站发了对up主谷歌的纠错视频，这篇文章测试几乎是在两年前做的，而写的时候大部分测试已经做完了不少时间了，而且写着写着发现有一些遗漏，还补做了一些测试，因此总体来说文章不是很通畅，希望各位见谅。我写这篇文章时，血源wiki给出的内脏暴击机制还不准确，是简单的技巧的倍率，而时隔两年，血源wiki已经给出了比我的文章更加准确的机制描述，而且这应该是通过直接解包游戏文件得来的。wiki里将两段伤害视作是武器的不同招式，而且第二段伤害针对不同触发方式有着不同的招式倍率。这种描述比我的更加简洁，显然也更正确。大家了解内脏暴击机制时，还是应以wiki为准。我在做测试之前，已经根据一些游戏现象怀疑内脏暴击的本质是武器，这个测试严格来说只是做了一些验证，严格来说，这篇文章并没有多少技术含量，而大都是“苦力活“，主要难点主要在分开测试属性和等级，我技术一般，而且本身偏向于枪反打法，只加力量拿到所有继承人符文并且成功使用失败者bug就是我最主要做的事也是最难的事了。做这些测试、写这篇文章的初衷之一也是因为之前各处关于血源的内脏暴击机制解释，大都不是很准确也不完整，对于一个热爱血源的玩家来说，还是一件挺遗憾的事情，总之能对大家有用，还是挺开心的，血源也要登录PS5了，希望到时候能畅享60帧的流畅血源。~~FS社垃圾优化，还爱疯狂塞粒子特效，会不会掉帧自己心里没点B数嘛~~

结论

内脏暴击是两把具有特殊补正曲线的不可附魔的隐藏武器，对应内脏暴击的两段伤害。

具体来说，内脏暴击是两把特殊武器打出的招式，为突刺属性，和普通武器的招式类似。这两把武器均只有内脏暴击这一个招式(或者说游戏内只能使用这一个招式)，因此我们可以认为其招式倍率为1。

具体到这两把武器本身，两把武器只有基础攻击力的区别，根据玩家等级，有11种不同的强化等级，同样与普通武器的强化等级类似，只是普通武器直接用血石材料升级，而内脏暴击武器自动随着玩家等级而升级。其不同强化等级对应的基础攻击力、玩家等级如下表所示。作为特殊武器，自带与强化等级无关的1.3(S)技巧补正，但其补正曲线与普通武器不同，我的测试的目的之一，就是确定其补正曲线。此外，其攻击力与伤害还与宝石、符文、兽丸、附魔、部分武器特殊效果加成相关，具体来说，任何装备中的右手武器上的宝石同样可以作用于内脏暴击，但其是否真正有效取决于不可附魔武器与宝石的作用规则，但作用规则这一点，没有做严格的验证。三个爪印符文直接增加10/20/30%的内脏暴击伤害，互相可以乘法叠加，且取整至整数百分比。兽丸可以增加至多70%的内脏暴击攻击力。附魔同样可以增加对应元素的攻击力，相当于对应属性的固伤宝石。特殊效果部分包括锯齿加成、教会加成和部分武器自带的特殊效果。除此之外，其攻击力或伤害与右手武器强化等级、灵视、玩家武器种类、右手武器宝石等因素没有直接关系。

此外，在本次测试结束之后，我才发现我想当然认为所有内脏暴击都是一样的，实际上有三种不同的内脏暴击触发方式，即枪反、背刺与爆头(对特定部位积累一定伤害才能打出)，本文中所提到的伤害测试，均使用枪反或者背刺完成。同样，我也没有考虑过内脏暴击是否有对boss或NPC的特殊作用。当然这些测试蛮难做的，我也不打算做了。我认为我的结论只适用于枪反与背刺内脏暴击，爆头内脏暴击应该采用了不同的内脏暴击武器，其第一段攻击力与我的结论相同，但第二段攻击力均高出50点。攻击力这一点是由贴吧的汉尼拔大佬于血源的数据库中获取的，但是否如我所猜想，对应爆头内脏暴击，并没有经过验证。此外我还认为内脏暴击对boss没有特殊作用，但显然NPC并不相同，一般NPC所受的内脏暴击伤害远低于普通敌人。其具体原理则很难确定，同样没有测试支持，也没有现成的结论。

下表为内脏暴击基础攻击力与人物等级关系。

强化等级	对应人物等级	武器1基础攻击力	武器2基础攻击力
+0	1-14	50	250
+1	15-29	55	325
+2	30-44	60	390
+3	45-59	65	570
+4	60-79	70	640
+5	80-99	75	720
+6	100-119	80	740
+7	120-139	85	760
+8	140-159	90	770
+9	160-199	95	780
+10	200-544	100	790

下图为内脏暴击的补正系数与普通武器的补正系数(红线为内脏暴击、蓝线为普通武器)，为有几个关键点的折线图。因测试时，普通武器的面板数值在200-400之间，造成其曲线误差较大，直线度比内脏暴击差一些。图中有几个关键点，大致如下，另外我们可以认为他们的起点都是0点0%：

普通武器：10点5%，25点50%，50点85%，99点100%

内脏暴击：10点10%，50点80%，99点100%

Figure 6: Snipaste_2019-02-16_12-56-58.png

这里我们已经可以得到内脏暴击的软上限了，也即大概在80级和50技巧的时候，其攻击力达到软上限，根据计算，此时其攻击力约为200级99技巧满攻击力时的(1+1.3*0.8)/(1+1.3)*720/790=0.8083654375343975，即约80.8%，当然这个结论是不考虑沉重深渊宝石时的结论，当考虑沉重深渊时情况又略有不同，此处不再赘述。

影响内脏暴击的因素，可以分为增加攻击力或伤害这两个大类，具体来说，有等级、属性、锐利/沉重宝石等间接影响内脏暴击攻击力的，也有突刺、锻炼、滋养、兽丸，物理固伤等直接增加百分比/固定内脏暴击攻击力的，还有各种元素固伤、附魔等增加固定元素攻击力的，还有爪痕符文、野兽/眷族猎人、锯齿/教会加成等增加百分比伤害的。这几类中，只有最后一类作用于攻击力伤害转换过程之后，一般来说提升攻击力的效果优于同数值的提升伤害的效果。当然，对于内脏暴击来说，因为第二段攻击力非常高，一般而言只要稍微有些加成，都会超过8倍敌人的突刺防御力。此时提升攻击力与提升伤害的效果完全一致，而第二段攻击是内脏暴击最最主要的部分，一般而言，其造成的伤害占比往往超过95%，因此对于实用而言，两类效果的区别并不大，没有必要严格区分这两类效果。

基础概念

为了方便描述，下面给几个数值命名，作为下文里的基础概念，一般来说，这些概念也可以适用于其他魂系列游戏。

基础攻击力: 武器的最基础的攻击力，一般只能通过强化武器等级来提升，在基础攻击力基础上，先由补正和补正系数来初步提升武器攻击力，再由百分比和招式倍率进一步提升攻击力，最后是固定攻击力提升。到了这一步就得到了计算伤害的最终攻击力。
基础伤害: 实际上并不存在这个概念，这里指完成攻击力-伤害转换后未经提升或削弱的最初伤害。基础伤害经过一系列的提升或削弱之后就可以得到最终的伤害值。
攻防比: 攻击者的最终攻击力和被攻击者对应属性防御力的比值。攻防比决定基础伤害与最终攻击力的比值。
攻击力伤害转换: 最终攻击力转换为基础伤害的过程，提升攻击力的效果作用于这个过程之前，提升伤害效果作用于这个过程之后。由于经过了这次转换，同时因为攻防比决定了基础伤害值与最终攻击力的比值，导致魂系列里提升攻击力与提升伤害的效果并不完全一致。一般来说，提升攻击力效果好于提升伤害，某些极限情况下他们效果完全相同。

以上这些概念同样完全适用于内脏暴击的作用过程。

我们定义攻击力效率=基础伤害值/最终攻击力。即减伤率=1-攻击力效率。（深蓝叫做穿透率，意思一样，但是他画的图像明显不对）

攻击力效率是攻防比的函数，约定atk为攻击力，dmg为伤害值，def为防御力，x为攻防比即x=atk/def，其具体形式为：

其图像为

Figure 7: Snipaste_2019-01-27_19-24-28.png

而基础伤害值与攻击力、防御力的函数可以表示为

以下是将防御力设为100时的图像

Figure 8: Snipaste_2019-01-27_19-36-26.png

这个公式据我所知应该是网友经过大量的试验测试出来的，不知道有没有大神看过魂系列的汇编代码做确认，但我们默认这个公式是正确的。一来是因为这个公式应该经过了许多试验，应该比较可靠，二来是假如不信任这个公式，那我们既有的信息就不太够我们设计测试以及得出结论了。

此外我还要提到我们的测试的基础，即我们的测试，是从某些我们假定正确的信息来推出另外一些我们未知的信息，那我们假定正确的信息都有哪些？

显而易见，游戏面板显示的数值信息。但其实这些信息未必非常可靠，因为这些数值都是经过取整(或者四舍五入，应该是单纯的取整)之后显示给我们看的。另外血源的数值真的有点玄学，举个例子来说，满级号1900血，带上5%的顺时针之后怎么算都是1995，但实际上却是1994。对于数值较大的情况，举个例子来说，1000点的数值大概只会有0.2%的误差，这对于我们来说是可以接受的。显而易见大数值得到的结论，其误差小于小数值的，故我们测试时应尽量提升数值。此外以下的测试均假定血源采用直接取整。
”官方“攻略本。官方攻略本错误不少，但大部分内容都是正确的，所以我们也会参考攻略本的内容，但官方攻略本上的内容，我们都会尽量做点简单的验证。
伤害公式。前面已经提到伤害公式f(x)和dmg=g(atk, def)，但光有这个其实还不太够，因为很多时候我们需要用伤害值和防御力反推攻击力，或者用攻击力和伤害值反推防御力。理论上来说，这三者大部分情况下是知二求一的，即知道两个就可以求出另外一个。少数情况下只能得到范围，但这些情况一来基本不可能出现，二来我们也不关心，所以无关紧要。因为伤害随攻击力单调上升，随防御力单调下降，所以我们可以简单的用二分法知二求一，这部分可以用python和matlab代码实现，不再赘述。

准备

我们已经有了基础，但在正式做测试之前，我们还有一些东西需要考虑。既然是做测试，那么测试的是什么？如何测试？如何达到测试的条件？如何控制变量？

内脏暴击伤害与什么相关，具体是什么关系。具体来说我们可以确定内脏暴击伤害与右手武器强化等级无关，这个就不用测试了（其实也是测试过的，但是就不多提了）。影响内脏暴击伤害的因素可以总结为等级、技巧值、宝石、符文、兽丸、附魔、特殊加成。等级和技巧并不是完全正交的，所以测试技巧的时候我们需要排除掉等级的影响，正好根据现有的一些结论，等级超过200级之后，等级不再影响内爆基础攻击力。因此我们可以在200级之前不加任何技巧，以最大限度的排除技巧的影响，在200级之后，我们可以再测试技巧对内脏暴击的影响，此时同样不会再受等级影响。

因此我们需要一个新号，从1-200级测试等级对内爆攻击力的影响，在200级以后测试技巧对内爆攻击力的影响。需要说明的是，这11个等级区间我在测试之前就知道了，出自一个论坛，我认为这个可信，只是需要具体的数据验证，我们仍然需要做大约21次测试，具体来说，分别在[4, 14, 15, 29, 30, 44, 45, 59, 60, 79, 80, 99, 100, 119, 120, 139, 140, 159, 160, 199, 200]这些等级测试，只要数据符合等级预期，中间的等级就无需测试。测试的对象我选择了亚楠中心碰到的第一个拿斧头和火炬的杂兵，根据官方攻略本，其突刺防御力为70，同时根据官方攻略本，手杖的蓄力突刺和不蓄力突刺都是突刺属性攻击力，倍率分别为1.9和1.35，经我简单验证，倍率和属性都没有问题。

使用两把强化程度不同的手杖进行测试，得到以下数据

攻击力	1.35	1.9
137	130	202
152	149	231

验证可得g(137*1.35, 70)=131.35, g(137*1.9, 70)=202.72, g(152*1.35, 70)=149.83， g(152*1.9, 70)=231.26 ，虽然第一个数据取整之后差了1，但还是可以认为官方攻略本的数据没问题。

由于进入多周目之后，杂兵的防御力也会提升，因此要求我们测试同一个因素时，其测试环境不能变，也就是说我们不能测试到100级再进入二周目继续测试，这要求我们一周目升到200级且不能升技巧，因此我们需要去三继承人双掏失败者。一周目得到的魂虽然不够我们升满级，但是做完等级和技巧的两个测试是够的。唯一的问题是需要继承人3，而继承人3在苏美鲁衣乎尔。第一次测试的时候我是真的老老实实打圣杯迷宫的，后来才发现有魔改迷宫这种方便的东西。。。

关于技巧的测试，由于杂兵太脆，无法得到第二段数值，我最后选择了噩梦教会前拿教会大炮的刽子手做测试对象。根据官方攻略本，其突刺防御力为268，做同样测试。两个火纸和雷纸的测试可以无视，最后也可以确定官方攻略本无误。

攻击力	1.35	1.9
303	234	393
303+火纸	249	408
303+雷纸	265	424

等级和技巧的测试算是可以进行了，而宝石、符文、兽丸、附魔、特殊加成的测试远比前面的简单，最终基本全部使用我的满级号在噩梦教会测试。

此外，在处理数据之前，还有一点需要提及，那就是内脏暴击伤害的处理。内爆伤害分为两段，其显示的数字也有两个，比如(71, 1688)，在这样一个数据里，第一个数字代表第一段伤害经过取整后的数值，第二个数字代表第一段伤害经过取整后的数值加上第二段伤害经过取整后的数值，也就是说是两段伤害取整之后的和。用程序员的话来说，大概是fir_num = int(first); sec_num = int(first) + int(second);，这个细节，也是在经过大量的测试之后敲定的。

测试

等级因素

测试等级因素的时候，如上述，采用亚楠中心杂兵作为测试对象，人物技巧9点，使用无宝石手杖进行内脏暴击，无爪印符文、兽丸、附魔等影响因素，在[4, 14, 15, 29, 30, 44, 45, 59, 60, 79, 80, 99, 100, 119, 120, 139, 140, 159, 160, 199, 200]这些等级进行测试，实际上我还在大约300级左右时测试过，数据与200级完全一致。

最终测出的数据如下，实际上1-3级无法测得，我们当成在技巧值不变的情况下与4-14级相等。实际上200级到544必然加技巧，实际伤害不可能维持在200级的数值，我们这里不予考虑。

等级	伤害数值	第一段攻击力区间	第二段攻击力区间
1-14	15，236	[55.1，56.6]	[278.6，279.6]
15-29	19，326	[60.5，61.7]	[362.3，363.3]
30-44	24，406	[66.1，67.1]	[434.7，435.7]
45-59	30，602	[72.5，73.7]	[635.6，636.7]
60-79	34，676	[77.3，78.4]	[713.3，714.4]
80-99	39，761	[83.0，84.1]	[802.2，803.3]
100-119	44，786	[88.6，89.7]	[824.4，825.5]
120-139	49，812	[94.0，95.0]	[847.8，848.9]
140-159	55，828	[100.3，101.4]	[858.9，860.0]
160-199	60，843	[105.5，106.6]	[870.0，871.1]
200-544	65，858	[110.7，111.7]	[881.1，882.2]

表格中伤害数值就是游戏显示的数值，第三列是经计算后第一段的攻击力的最小值和最大值，第四列是第二段的攻击力的最小值和最大值。所有攻击力值均取到小数点后一位。目前我们可以看到其攻击力和我们一开始的结论还不一样，这是因为我们有9点技巧，这9点技巧结合1.3(S)的技巧补正会带来约为11.7%的提升。

我在论坛上看到了其他玩家的测试以及官方的数据，如下：

等级	倍率	等级	倍率
4	1	4～14	1
5～29	1.3	15～29	1.2690
30～44	1.56	30～44	1.5035
45～59	2.28	45～59	2.1195
60～79	2.56	60～79	2.3700
80～99	2.88	80～99	2.6540
100～119	2.96	100～119	2.7400
120～139	3.04	120～139	2.8200
140～159	3.08	140～159	2.8700
160～199	3.12	160～199	2.9200
200～	3.16	200～	2.9700

左边是攻略本数据，右边是玩家的测试，那么画出图来呢，如下，绿色为玩家测试，红色为攻略本数据，蓝线为我的内脏暴击武器2的数据，和红线几乎完全重合。

Figure 9: Snipaste_2019-01-27_21-58-54.png

可以看到，虽然绿线总体趋势相同，但比例还是差很多。此外橙色的菱形是开头的结论，将其乘上一个约为1.117的系数即可得到黄色菱形那条线，可以看到与红蓝折线完全重合。所以这个系数又是怎么来的呢？简单来说就是我们猜14级以下内爆第二段的基础攻击力为250，这样就可以得出这个系数，这个系数也代表了内爆技巧补正在9点技巧的时候可以有约9%的效果，即1.117 = 1 + 1.3*0.09。问题之二，如何验证这是对的，图是一个方面，还可以从其他方面验证吗？当然可以，后面我们测得了内爆的技巧补正为1.3，这个时候给手杖打一个12的锐利宝石，那么根据理论，计算出第二段的攻击力应该为(790 + 790 * 1.3 * 0.09 + 790 * 0.12 * 0.09) = 890.96 ，此时对杂兵用内爆第二段可以造成801.8点伤害。实际测试数据为(66, 866)，第二段伤害为800点，误差约为0.2%，基本符合。

可以看到官方攻略本的数据实际上是第二段伤害的倍率，第一段伤害，其基础攻击力随等级区间而均匀递增，其基础攻击力仅约为第二段的1/8，由于攻击伤害计算机制，第二段伤害一般会远远超过第一段伤害的8倍。到此关于等级的测试完毕。

属性因素

这里之所以说是属性因素而不是技巧因素，是因为实测技巧加成是以技巧补正的形式作用的，而沉重宝石增加的力量补正同样可以作用于内脏暴击武器，也就是说，内脏暴击同样可以跟力量有关。但这里仅限于力量与技巧，血质与秘法将在后面再说。

关于属性因素，为了测得内脏暴击的补正曲线，我一共做了5组不同的测试，测试环境一致(测试力量与技巧时，因为用了不同的号，等级可能不一样，但均在200级以上，排除等级因素)

如上述，我选择了噩梦教会前拿教会大炮/斧头的刀斧手(刽子手)作为测试对象，经过测试，他们一周目的突刺防御力均为268。人物等级200级以上，属性范围从9-99，不装备爪痕，不使用兽丸等影响内脏暴击伤害的物品。以下为5组测试的不同：

武器为手杖，无宝石，使用手杖形态内脏暴击。
武器为手杖，18.2物理固伤宝石，使用手杖形态内脏暴击。
武器为手杖，无宝石，使用鞭子形态内脏暴击。
武器为手杖，15.2技巧关联性宝石，使用手杖形态内脏暴击。
武器为手杖，15.8+8.4力量关联性宝石，使用手杖形态内脏暴击。

大体而言，前四组为同一个号，其等级在200级以上，技巧为9-99点，第5组是另外一个新号，其等级为200级以上，技巧为99点，力量为9-99点(使用了魔改迷宫取巧，也懒得刷好的沉重宝石，就凑合用两个垃圾沉重了)。第一组可以测出内脏暴击武器的补正曲线，第1组和第2组对照，可以得出固伤宝石的作用。第3组和第4组是为了确定手杖的鞭子形态自带15锐利宝石的说法。第5组是为了确定内脏暴击武器其力量补正曲线是否与技巧补正曲线一致。同时我还测过14.7锐利宝石效果与15.2没有区别。

属性等级	第1组	第2组	第3组	第4组	第5组
9	14, 677	19, 700	15, 688	15, 688	73, 1707
10	15, 689	19, 711	15, 701	15, 701	73, 1709
11	15, 707	20, 729	16, 721	16, 721	73, 1712
12	16, 725	21, 747	16, 741	16, 741	74, 1716
13	16, 742	22, 766	17, 761	17, 761	74, 1720
14	17, 761	22, 784	18, 782	18, 782	74, 1723
15	18, 780	23, 802	18, 802	18, 802	75, 1727
16	18, 797	24, 821	19, 823	19, 823	75, 1731
17	19, 816	25, 840	20, 844	20, 844	75, 1734
18	20, 835	25, 858	21, 865	21, 865	76, 1738
19	20, 853	26, 877	21, 885	21, 885	76, 1741
20	21, 872	27, 896	22, 906	22, 906	76, 1745
21	22, 891	28, 916	23, 927	23, 927	77, 1749
22	22, 909	29, 935	24, 949	24, 949	77, 1752
23	23, 929	30, 954	25, 970	25, 970	78, 1756
24	24, 948	31, 973	26, 992	26, 992	78, 1760
25	25, 967	32, 993	27, 1013	27, 1013	78, 1763
26	26, 987	33, 1012	28, 1035	28, 1035	79, 1767
27	26, 1005	34, 1032	29, 1057	29, 1057	79, 1771
28	27, 1025	35, 1051	30, 1078	30, 1078	79, 1774
29	28, 1044	36, 1071	31, 1100	31, 1100	80, 1778
30	29, 1064	37, 1090	32, 1122	32, 1122	80, 1781
31	30, 1083	38, 1110	33, 1144	33, 1144	80, 1785
32	31, 1103	39, 1129	34, 1165	34, 1165	81, 1789
33	32, 1122	40, 1149	35, 1187	35, 1187	81, 1792
34	33, 1142	42, 1170	36, 1209	36, 1209	82, 1796
35	34, 1162	43, 1189	38, 1232	38, 1232	82, 1799
36	35, 1181	44, 1209	39, 1254	39, 1254	82, 1803
37	36, 1201	45, 1229	40, 1276	40, 1276	83, 1807
38	37, 1221	47, 1250	42, 1299	42, 1299	83, 1810
39	38, 1241	48, 1269	43, 1320	43, 1320	83, 1813
40	39, 1260	49, 1289	44, 1342	44, 1342	84, 1818
41	41, 1281	51, 1310	46, 1365	46, 1365	84, 1821
42	42, 1301	52, 1329	47, 1387	47, 1387	85, 1825
43	43, 1320	54, 1350	49, 1410	49, 1410	85, 1828
44	44, 1340	55, 1370	50, 1431	50, 1431	85, 1831
45	45, 1360	57, 1390	52, 1454	52, 1454	86, 1836
46	47, 1380	58, 1410	54, 1477	54, 1477	86, 1839
47	48, 1400	60, 1431	55, 1498	55, 1498	86, 1842
48	50, 1421	61, 1450	57, 1521	57, 1521	87, 1846
49	51, 1440	63, 1471	59, 1544	59, 1544	87, 1849
50	52, 1460	65, 1491	60, 1565	60, 1565	88, 1854
51	53, 1465	65, 1496	61, 1571	61, 1571	88, 1854
52	53, 1469	66, 1501	61, 1576	61, 1576	88, 1855
53	53, 1474	66, 1505	62, 1581	62, 1581	88, 1856
54	54, 1479	66, 1510	62, 1586	62, 1586	88, 1857
55	54, 1483	67, 1515	63, 1592	63, 1592	88, 1857
56	54, 1488	67, 1519	63, 1597	63, 1597	88, 1858
57	55, 1493	68, 1525	63, 1601	63, 1601	88, 1859
58	55, 1497	68, 1529	64, 1607	64, 1607	88, 1860
59	55, 1502	68, 1533	64, 1612	64, 1612	88, 1860
60	56, 1507	69, 1538	65, 1618	65, 1618	89, 1862
61	56, 1511	69, 1543	65, 1622	65, 1622	89, 1863
62	57, 1517	70, 1548	66, 1628	66, 1628	89, 1864
63	57, 1521	70, 1552	66, 1633	66, 1633	89, 1864
64	57, 1525	71, 1558	67, 1638	67, 1638	89, 1865
65	58, 1530	71, 1562	67, 1643	67, 1643	89, 1866
66	58, 1535	71, 1566	67, 1648	67, 1648	89, 1867
67	58, 1539	72, 1571	68, 1654	68, 1654	89, 1867
68	59, 1544	72, 1576	68, 1658	68, 1658	89, 1868
69	59, 1549	73, 1581	69, 1664	69, 1664	89, 1869
70	59, 1553	73, 1585	69, 1669	69, 1669	90, 1871
71	60, 1558	74, 1591	70, 1674	70, 1674	90, 1871
72	60, 1562	74, 1595	70, 1679	70, 1679	90, 1872
73	61, 1568	74, 1599	71, 1685	71, 1685	90, 1873
74	61, 1572	75, 1604	71, 1689	71, 1689	90, 1873
75	61, 1576	75, 1609	72, 1695	72, 1695	90, 1874
76	62, 1582	76, 1614	72, 1700	72, 1700	90, 1875
77	62, 1586	76, 1618	73, 1705	73, 1705	90, 1876
78	62, 1590	77, 1623	73, 1710	73, 1710	90, 1876
79	63, 1595	77, 1628	74, 1716	74, 1716	90, 1877
80	63, 1600	78, 1633	74, 1720	74, 1720	90, 1878
81	64, 1605	78, 1637	75, 1726	75, 1726	91, 1880
82	64, 1609	78, 1641	75, 1731	75, 1731	91, 1880
83	64, 1613	79, 1647	76, 1736	76, 1736	91, 1881
84	65, 1619	79, 1651	76, 1741	76, 1741	91, 1882
85	65, 1623	80, 1656	77, 1747	77, 1747	91, 1883
86	66, 1628	80, 1660	77, 1751	77, 1751	91, 1883
87	66, 1632	81, 1665	78, 1757	78, 1757	91, 1884
88	66, 1637	81, 1670	78, 1761	78, 1761	91, 1885
89	67, 1642	82, 1675	79, 1767	79, 1767	91, 1886
90	67, 1646	82, 1679	79, 1772	79, 1772	91, 1886
91	68, 1651	83, 1684	80, 1777	80, 1777	91, 1887
92	68, 1655	83, 1688	80, 1782	80, 1782	92, 1889
93	68, 1660	84, 1694	81, 1787	81, 1787	92, 1889
94	69, 1665	84, 1698	81, 1792	81, 1792	92, 1890
95	69, 1669	85, 1703	82, 1797	82, 1797	92, 1891
96	70, 1674	85, 1707	82, 1802	82, 1802	92, 1892
97	70, 1678	86, 1712	83, 1808	83, 1808	92, 1892
98	71, 1684	86, 1717	83, 1812	83, 1812	92, 1893
99	71, 1688	87, 1722	84, 1818	84, 1818	92, 1894

首先说第3和第4组，他们的数据完全一样，这说明至少在内脏暴击这一方面，鞭子相当于手杖+15锐利宝石，为鞭子自带15锐利宝石提供了非常有力的证据。

根据以上数据，再结合突刺防御力=268与攻击力、防御力、伤害知二求一的关系，可以计算出这五组数据对应的第一段第二段内脏暴击攻击力，画出前四组的图像，如下：

第一段：图中红线为第1组，绿线为第2组，蓝线为第3组和第4组。可以看到红线与绿线距离基本保持不变，约为18，而蓝线的斜率明显大于红绿线，这是因为蓝线有0.15的技巧补正。

Figure 10: Snipaste_2019-02-18_02-30-07.png

第二段：图中红线为第1组，绿线为第2组，蓝线为第3组和第4组。分析同上图，由于第二段的数值较大，在800-2000之间，因此其直线度非常好，适合用于数据分析，可以减小误差。

Figure 11: Snipaste_2019-02-18_02-29-20.png

首先因为99技巧时第二段攻击约为1817，因此内脏暴击的技巧补正=(1817-790)/790=1.3，第一段攻击的攻击力也约为230点，同样可以算出1.3的技巧补正，也就是说第一段和第二段的武器其技巧补正相同。我比较相信这个值的原因之一是他还是比较“整”的，不是什么1.32342342…，当然这只是个很小的原因，之后我们还可以通过各种数据来互相验证。我最初算出技巧补正是1.3还是从满级号的沉重深渊对内脏暴击的攻击力加成接近于28.3%这里算出来的。

通过第二组数据，我们可以看到物理固伤宝石同时作用于第一段和第二段内脏暴击，且提供固定物理攻击力提升，理论上来说，不会受兽丸等手段的进一步提升。

我们还可以算出鞭子/0.15技巧补正加成在99技巧时可以带来6.53%的攻击力加成，与理论值0.15/(1+1.3)=6.52%基本一致，可以看到误差非常小。

补正曲线

计算技巧的第二段攻击力的补正系数时，其公式为 (atk-790)/790/1.3 ，计算力量的第二段攻击力的补正系数时，其公式为 (atk - 790*2.3)/790/0.24 。计算第一段时，只需将790替换为100即可。

以第1组和第5组数据可以分别得到技巧和力量的补正曲线，如下图所示。

其中红色为技巧第一段攻击力的补正曲线，绿色为力量第一段攻击力的补正曲线。

紫色为技巧第二段攻击力的补正曲线，也是直线度最好的一条，和本文开头给出的是同一条，蓝色为力量第二段攻击力的补正曲线。

Figure 12: Snipaste_2019-02-18_01-10-51.png

可以看出，这四条线实际上是同一条，只是因为取整等原因，使得他们看起来有些很精细，有些很粗糙。同时，我们可以推测出，血源在展示数据之前是经过取整而非四舍五入的，因为这些粗糙的图像都在精细图像的下面，且会周期性的向精细的图像靠近。假如是四舍五入，那么粗糙的图像就会在精细图像的附近，且基本以精细图像为中心位置。当然这个问题其实根本不重要，所以也无所谓了。

同时我们可以大胆推测，内脏暴击的补正曲线实际上是由以下几个点连成的折线图。

(0, 0), (10, 0.1), (50, 0.8), (99, 1)

如下图所示:

Figure 13: Snipaste_2019-02-19_21-04-08.png

至此我们得到了内脏暴击自带的技巧补正，还测量得到了随属性点数变化的补正曲线，关于属性因素的测试到此就结束了。

其他因素

其他因素基本包括不限于：爪痕、兽丸、各类宝石、附魔、特殊加成等。对于这些因素，我们最主要的问题还是搞清楚，哪些因素对内脏暴击有加成，以及是提升攻击力还是提升伤害。由于这些数值都很清楚，也就没有必要做非常详细的计算。

爪痕

在做测试的过程中，爪痕是最令我意外的一个，爪痕的描述上清清楚楚的写着增加攻击力(中英三个版本均是)，然而实际测试中，我发现爪痕的效果实际上是增加伤害，不知道是否与版本更新相关。

以下为我的测试数据，测试对象和等级属性武器条件同上：

测试条件	伤害	提升百分比	理论
26.3%锻炼+26.3%锻炼(2，3的对照组)	193，2799	-
26.3%锻炼+26.3%锻炼+30.4%突刺(4-10的对照组)	301，3699	0%	0%
26.3%锻炼+26.3%锻炼+30%爪痕	252，3640	-
26.3%锻炼+26.3%锻炼+30.4%突刺+10%爪痕	331，4069	10.01%	10%
26.3%锻炼+26.3%锻炼+30.4%突刺+20%爪痕	362，4439	19.98%	20%
26.3%锻炼+26.3%锻炼+30.4%突刺+30%爪痕	392，4809	29.99%	30%
26.3%锻炼+26.3%锻炼+30.4%突刺+10%爪痕+20%爪痕	398，4883	31.99%	32%
26.3%锻炼+26.3%锻炼+30.4%突刺+10%爪痕+30%爪痕	431，5290	43.00%	43%
26.3%锻炼+26.3%锻炼+30.4%突刺+20%爪痕+30%爪痕	470，5771	56.00%	56%
26.3%锻炼+26.3%锻炼+30.4%突刺+10%爪痕+20%爪痕+30%爪痕	516，6326	70.98%	71.6%

对比第1、2、3组数据我们可以发现，30.4%突刺和30爪痕的第一段伤害差别很大，有49点，而第二段伤害差别只有10点，具体来说，突刺宝石提升了第一段56%的伤害，第二段30.4%的伤害，而爪痕对第一第二段的提升一致，均为30%，这是为什么呢？

细究之下，我发现30.4突刺增加的是攻击力，作用于攻击力-伤害转换之前，其提升一般来说大于直接提升伤害。30%爪痕提升的是伤害，作用于攻击力-伤害转换之后，其提升固定为一百分比。当提升攻击力的效果在原本攻防比处在(0.1， 2.5)之间时，提升攻击力的效果往往大大优于同数值的提升伤害的效果。在这里体现为30.4突刺对第一段的提升远远大于30%爪痕对第一段的提升。同时这里也体现了突刺宝石作为提升攻击力的效果，其最后的伤害提升有可能会高于标注的数值。

这里我不再详细的计算数据，但我们可以得到爪痕提升伤害，突刺宝石提升攻击力的结论。

同时，对于几种不同的爪痕组合，我们可以分别计算出他们提升的百分比，我们可以得到爪痕相互乘法叠加的结论。然而，实际上10%+20%+30%应当是1.1*1.2*1.3 - 1 = 0.716 ，实际上却是70.98%，实际伤害会差约20点，其余组合则没有这个问题。

此外，既然说到爪痕，则不能不提到复制bug，通过复制bug可以得到多个20%爪痕符文，因此我们还可以测试一组。由于需要开新号，为求速度不再多升级。直接跑图快速血月再进魔改迷宫拿全爪痕。

测试条件如下：

人物等级42级，30技巧，锯肉刀带12%锻炼+18%锻炼+2.7%锻炼。

测试对象，禁忌森林第二段的刀斧手，突刺防御力为239。

测试条件	伤害	提升百分比	理论
无爪痕	21，664	0%	0%
20%爪痕+20%爪痕	31，957	44.01%	44%
10%爪痕+20%爪痕+20%爪痕	34，1050	58.01%	58.4%
20%爪痕+20%爪痕+20%爪痕	37，1143	72.00%	72.8%
20%爪痕+20%爪痕+30%爪痕	40，1243	87.09%	87.2%

提升百分比精度约为0.15%，可以看到这些百分比都相当接近于整数，从这里我们可以得出规律，爪痕相互乘法叠加，但数值上最多取整到小数点后2位（或者说百分比取整）。比如10%+20%+30%，理论提升为71.6%，但会取整为71%。

兽丸、宝石、附魔

这三个同时进行测试，而到了这一步，我们要做的已经很简单了，就是搞清楚这些因素是否对内脏暴击有提升，如果有，提升的是攻击力还是伤害。

在进行测试之前，我首先使用满级、封顶周目的号，使用无宝石+6失落手杖对噩梦教会前的刀斧手(突刺防御力约为360)进行了基础的伤害测试，取其伤害值作为基础的对比。之后，假如两段伤害提升百分比差不多且等于效果数值，则是提升伤害，若提升第一段明显大于提升第二段，则是提升攻击力。

条件	伤害
无爪痕	47，1577
30%爪痕	61，2051

以下我先列出一些没有提升效果的宝石的测试

宝石	伤害
精通-钝击30.4%	47，1577
血质21.6%	47，1577
秘法18%	47，1577
火焰25.3%	47，1577
闪电26.3%	47，1577
温暖，血质关联+26.3（使用赛门弓刃测试）	47，1577
蓄力29.7%	47，1577
物理攻击力+8.1%，对公开敌人攻击力+10.8%	56，1739

以下宝石效果应该没有提升，但是由于无意义或者我没有这类宝石效果，没有测试过：

寒冷、浑浊、污秽、闪耀、脉动、致命、密集

公开敌人的宝石效果我之前有测试过，但未记录数据，之后专门测试的时候找不到合适的宝石测试，凑合用着了。根据计算可以确定他的提升来自物理8.1%。因此对公开敌人的宝石效果对内脏暴击无效。

此外还有一个特殊的宝石效果，古怪血质，提升固定的血质攻击力，理论上来说应该有提升，但因为固定部分数值过低，我能拿到的最好的固定数值仅为6.8，因为其提升的伤害不到1点，也就无法测试，也没有任何实用价值。

之所以先将没有提升的效果拿出来，是因为我们很难得到想要的单一效果的宝石，也就很难测试，而确定了这些效果无提升之后，我们选择宝石的时候范围就会更广。

部分对内脏暴击有效的宝石效果（括号内为附带的无关效果，可能未全部记录，但确认均不提升内脏暴击）：

宝石(噩梦教会刀斧手)	伤害
无	47，1577
古怪秘法47.3(秘法4.1%)	51，1586
古怪火焰67.5(火焰8.8%)	55，1594
古怪闪电14.5(火焰23.9%)	48，1580
古怪锻炼18.2(钝击23.4%)	55，1604
精通-突刺30.4%	89，2189
沉重65	85，2146
锻炼27.2%	83，2124
锐利26.3	60，1804
滋养21.5%	74，2009
愚物27.2%	83，2124
穷物28.6%	86，2154

以上效果可以大致分为几类，元素固伤类，直接提升突刺攻击力的，和通过提升补正来提升突刺攻击力的。

元素固伤可以给内脏暴击添加对应的属性攻击力，对第一段和第二段均有效，根据被掏的敌人对应的防御力来单独计算伤害，相当于魂3的混伤，同时也可以由爪痕进一步提升伤害值。

非元素固伤类的提升本质上是提升突刺属性攻击力，分为直接提升和间接提升两种，直接提升部分没什么好说的，基本就是百分比提升宝石和固伤宝石，大家都懂。间接提升的就是锐利宝石和沉重宝石，锐利宝石由于其数值过低，不具有实用价值，而沉重深渊宝石则可以提升65力量关联性，因此满属性情况下，其一般可以提升0.65/2.3=28.26%的内脏暴击攻击力，优于一般的272宝石。当使用鞭子内爆时，提升则约为26.5%，不到27.2%。（另外多说一句，一个沉重深渊加成超过272的阈值条件是补正总和小于1.4，基本上就只有圣剑了~）

以上所有的宝石效果均为提升攻击力，同等数值和条件下一般优于提升伤害。

以下是两种特殊的宝石效果，对特殊分类敌人的特殊加成。

对野兽伤害提升：

宝石(变异猪)	伤害
锻炼27.2%	171，2250
锻炼27.2%+野兽-10.9%	152，2004

由于152/171约等于(2004-152)/(2250-171)约等于(1-0.109)，因此这类效果属于提升伤害的效果。

对眷族伤害提升：

宝石(迷宫里的大头娃娃)	伤害
无	207，1842
眷族+31.5%	272，2422

由于272/207约等于(2422-272)/(1842-207)约等于1.315，因此这类效果属于提升伤害的效果。

兽丸、附魔：

条件(噩梦教会刀斧手)	伤害
无	47，1577
兽丸1	128，2577
兽丸2	169，2949
雷纸	66，1616
火纸	58，1599
幻像外壳	55，1594

易知兽丸为提升攻击力的效果，根据兽化程度不同，可以提供最大70%的攻击力提升。这里可以看到第一段提升70%攻击力可以让最终的伤害提升约259%，足见提升攻击力效果在特定情况下远远优于提升伤害，没错，就是压级号。

附魔与元素固伤类似，不再赘述。

特殊加成

特殊加成部分包括锯齿加成、教会加成和武器自带的特殊效果。

很遗憾这部分我做的测试非常少，而且没有记录下数据。只记得测过锯肉刀的锯齿加成有效而锯矛的无效，而且这两个加成属于提升伤害的。

武器特殊效果中，最值得一提的还是手杖的鞭子形态，自带15锐利宝石，在99技巧时默认可以提升内脏暴击0.15/(1+1.3)=6.52%攻击力。

总结

这篇文章的数据我前前后后几乎测试了两个多星期吧，后期的写代码、数据处理、写文章更是划了整个寒假，没错就是划，摸鱼一时爽，一直摸鱼一直爽~~塞尔达天下第一~~。从结果上来说，算是差不多搞清楚了内脏暴击的内在机制。不过也是有一些缺陷的，许多测试跟预测跟最后的结果往往有1点的误差，这个很难说是哪里的问题，比如说有可能是血源在计算伤害的过程中有多处取整操作。当然本来血源的数据就是玄学，比如我在测突刺攻击的伤害的时候，往往会有同一种攻击动作造成的伤害有1点的浮动。本来我想把锯齿加成等特殊效果也看成是宝石效果来处理，但后来发现锯齿加成之间也是有区别的。锯肉刀的锯齿加成可以提升内脏暴击，锯矛的却不可以。只能假设说这两个锯齿加成本身就不一样，对内脏暴击有不同的判定。但这个也无法验证，没有实际意义。本来我做的事情就不是提出底层模型而解释各种现象，而是总结出内脏暴击伤害计算的数学模型/程序。当然把内脏暴击看待为隐藏武器这一点也算是个底层模型了，但也是基于大量数据而总结出的，我看b站视频，大佬们把内脏暴击看成武器的招式，在我看来是不成立的，作为武器的招式，其攻击力不可能与武器的攻击力无关。再各种测试中，我们可以看到内脏暴击与武器的许多相似之处，比如都有11个不同的强化等级，都有类似补正的攻击力提升机制，都可以通过宝石提升效果，同时他的攻击力属性为突刺属性，可以解释为这个武器就一个可以用的招式是突刺攻击，倍率是1。

总之我认为我总结的这个模型用来计算血源内脏暴击伤害来说，已经相当完善了，基本上方方面面都照顾到了，已经差不多可以用来写一个内脏暴击伤害计算器了。具体如何计算，大概是先由人物等级确定两段基础攻击力，再由宝石、武器特殊效果和人物属性来确定内脏暴击的补正和补正系数，进一步提升攻击力，再根据兽丸、宝石等提升百分比攻击力，再由宝石提升固定攻击力，再由宝石添加固定的元素攻击力。这一步之后经攻击力伤害转换算出基础伤害，再由爪痕符文、特殊宝石效果、锯齿/教会加成等提升最终的伤害。手杖作为唯一同时有教会加成和锯齿加成还有隐藏15锐利宝石效果的武器，~~毫无疑问是内爆最佳武器~~。说得好我还是选择锯肉刀。

另外根据我粗略的计算，极限情况(可以考虑复制bug)，内脏暴击可以打出2w+的伤害。当然不会超出2w多少。

全文完

后记：在我发了这篇文章之后，贴吧的汉尼拔大佬提出来游戏数据中存在不同于我的结论的第二段攻击基础攻击力，貌似是对boss的，具体数值为[300, 375, 440, 620, 690, 770, 790, 810, 820, 830, 840]，相对于我的结论来说，都增加了50。我测试的时候以为各种内脏暴击数值都相同，因此也没有特意去测试boss的伤害。后来粗糙的测试了圣职者怪兽和神父第一阶段，根据数据来说，内脏暴击对圣职者怪兽是有额外攻击的，而对神父一阶段没有。我猜测这可能是因为打出处决的方式不同，一个是肢体破坏，一个是枪反。假如这个结论成立的话，那么内脏暴击就多了一个隐藏武器，也就是说，根据打出处决的方式不同，第二段会使用不同的内脏暴击武器。这一点还需要进一步的测试，这个以后再说吧。懒人你伤不起。。。orz

ref:

第一个SKSE插件

2018-07-02T00:00:00Z

最近也是花了点时间研究了一下老滚，主要还是在开发方面，也花了点时间玩了一会。

老滚这游戏确实有自己独特的魅力，游戏本体本身非常开放，有非常广阔的世界、丰富的任务、多样的NPC、剧情也很多。任务虽然一直在指引你，但是你大部分时间都可以随时停止随时开始，所以不会有很多游戏大部分时间都被任务牵着走或者说线性的感觉。

老滚（或者说B社）官方支持mod，提供mod支持的同时，还提供MOD制作的工具CK，将游戏内容开放给所有玩家。但是既然开放，这样怎么会够呢，虽然mod能做出很强大的效果，但毕竟有限，就算是支持脚本编程，API也是有诸多限制的。这时候就轮到skse上场了，skse是国外的一个团队开发维护的，主要目的是拓展老滚的脚本API，例如缺失的键盘响应。skse还逆向了老滚里的不少class，当然不是完全逆向，而是识别了很多成员变量和函数的作用。另外skse提供了统一的插件接口，这使得所有程序员可以方便的为老滚编写插件，假如老滚有什么地方让你觉得不满意，你只需要定位到你要修改的代码，简单的修改或是hook它，来改变老滚的引擎的行为，最终你只需要编译成一个dll，放在指定的目录，skse会自动加载你的插件，从而使得你获得修改游戏引擎的能力，而且不会对老滚的程序本身有任何影响（不会修改老滚的可执行程序，而是运行的时候动态修改在内存里的机器指令）。这使得几乎每个老滚mod玩家都离不开skse，因为现今，许多mod直接以skse为前置，比如SkyUI这样的N网endorses排第一的基础mod，更多的mod以包含skse插件的形式间接的依赖于skse，比如几乎是老滚物理插件唯一选择的hdt物理插件，改变第一人称视角（为第一人称视角添加身体）的Enhanced Camera。

16年重置版发布之后，由于整个游戏从32位变为64位，SKSE团队不得不重新构建SKSE，这个过程花了将近一年，终于在去年9月份发布了第一个Alpha版本。此后大量的skse插件被移植到重置版。

skse为mod作者提供了许多接口，包括注册自己的papyrus函数、存档支持、Scaleform接口、消息接口等，一个skse插件需要至少实现并导出两个函数，一个用来判断版本是否合法（由于其特殊性，skse本身只支持一个版本，而mod可以支持多个版本，区别是实现会复杂一些），一个用来加载插件、hook函数、注册papyrus函数等。做一个skse插件你需要一些基础的c++知识，比较熟悉汇编语言，再通过ida分析老滚的汇编代码，找到你想要修改的代码，在加载插件时修改，编译成相应的dll，再通过skse加载好自己的插件，就完成了skse插件的制作。

由于Real Flying的作者在三年前就弃坑了自己的mod，这个mod一直没有被完整的移植到重置版，关键就是没人写出SKSE64插件支持飞行功能。通过看源代码，我了解到这个插件是通过hook一个处理Actor物理的函数（这个函数每帧会调用一次，改变Actor的位置速度等物理状态）来实现飞行的。简而言之，hook掉这个函数，通过一个全局变量fJumpHeightMin的值判断飞行状态，再根据不同的状态，在实际调用这个函数之前，修改不同方向的速度，来达到上升下降滑翔的效果，再通过FNIS播放一个Idle动画和自带骨骼和behaviour的翅膀模型，来使角色做出相应的动作。由于使用的是简单的idle动画，无法在飞行时攻击，也不支持第一人称（因为第一人称没有身体）。

整个插件实际上比较简单直接，移植并不需要修改多少东西，主要的工作还是重新确定函数地址、变量偏移量。skse64本身逆向了一些类和地址，所以其实真正需要找的已经不多了。另外就是64位程序的基地址不再是一个确定的值，涉及到地址的代码均需要简单修改。此外，之前用的hook库在64位下不再能用，还需要换一个hook库（或者手写汇编，还是别为难自己了- -），总之这些工作做完，再把程序编译成64位dll就可以了。

后来我还联系作者要了权限，感觉其实不应该要这个权限的，因为我对动画什么的一窍不通- -暂时也只能这样了，还好脚本还是可以改改的。这篇主要还是关于skse插件的，别的碰到的问题也就不多提了。

新的开始

2018-05-24T00:00:00Z

最近也是重新考虑再写写博客，也是试了几个流行的框架，以前用的Ghost现在已经有些臃肿了，我这1核心1GB内存 1M网速的VPS怕是已经带不动了，安装了两次都失败了，我也懒得再弄了，其他有后台的博客框架也不太会弄（并不懂PHP），所以最后还是回归了Hexo这个最初使用的框架，Hexo并没有后台，只负责将你的markdown日志生成博客的html静态文件，然后发布到Github Page或者VPS或者其他平台上。

总之Hexo用起来会不如其他有后台的框架来的方便，需要自己生成再发布（当然现在其实很方便了，一键生成+发布，再搭配一个好用的markdown编辑器，用起来也是很方便的），同时Hexo并不依赖VPS，只要有静态存储空间就可以了。

今天也是花了些事件在自己电脑上安装了nodejs、hexo，选了个自己喜欢的主题，再稍稍修改了一下，支持了Mathjax。另外把自己之前在Ghost上写的几篇博客也迁移了过来，图片暂时是没了。

其实倒是没什么关系，反正也没什么要紧的东西，再者重新写博客，也不知道能不能坚持的下去。

说来FS今天发布了魂1的重置版，说实话我是稍微有点失望的，可能是因为我期望太高了吧，毕竟魂1在我心目中的地位是非常之高的。可能毕竟只是remaster不是remake吧，基本上只相当于官方出了高清材质包+60帧补丁+联机补丁+若干bug修复+附送若干bug吧。其实看得出来，很多玩家的心情都和我差不多，也由于恶心的中文加载bug和没适配高刷新率屏幕，没过多久，steam评论就已经是褒贬不一了。感觉上意义比较大的就是解锁了帧率，让游戏整体的流畅度有所提升。至于画质，感觉并没有很明显的提升。

说起来魂1我玩的也不多，它的有些缺点对我来说太影响体验了，不过好歹是梦开始的地方，真的有点想去传火啊。可惜真的怕没什么时间~

从传送机器说开去

2017-04-17T00:00:00Z

假定现在有一个传送机器，它可以将你身上所有的基本粒子打散，然后将这些信息以光速传送到另外一个地方，再将这些基本粒子重新组合起来。你会坐这个传送机器吗？有些人认为，既然传送前后构成自身的粒子及其排列方式完全一样，那么传送前后的两个人就是同一个人，也有人认为，原来的人在打散的过程中就死掉了，后来重新组合而成的，只不过是一个一模一样的复制体。

更进一步的，假如机器出了问题，并没有将原来的人分解，但仍然将信息传送到了远处而重新组合出了另外一个人呢？那么这个人是谁，和你是什么关系呢？对于第二个问题，物理学家有个非常简单取巧的答案，根据量子不可克隆原理，这样对一个未知的量子态进行复制是不可能实现的，也就是说，不可能出现两个一模一样的个体。这当然在某种程度上算是解决了我们的问题，但是简单的规避这个情境其实并不能真正让我们满意，因为我们关心的其实是这里的哲学思考，而并非是技术上的可行性。而这里的哲学思考，则是个体的本质，简单来说，一个人是由一些基本粒子组成的，但人是否仅仅是这些基本粒子的组合。人是否还有某些非物质的东西，比如灵魂。

对这个问题的讨探古已有之，古希腊有个哲学家普鲁塔克曾经提出一个哲学问题：忒修斯之船。许多哲学家认为即使这艘船的所有部件都被替换了，这艘船仍然是原来的船，因为事物不仅仅是组成元素之和，而有其更加本质的本因。如果认为事物仅仅是组成元素之和，那么万事万物时时都在变化，如赫拉克利特的河流一般，人不可能两次踏入同一条河流，就会引发事物的同一性的危机。

虽然这个问题在古代就提出了，但在现代则有了进一步的发展，随着近代科学的发展，人们逐渐认识到事物都是由基本粒子构成的，而构成事物的基本粒子，是完全等同的，同类的粒子之间本质上是不可区分的。这世上有数不清的电子，这些电子的属性是完全一模一样的，所不同的是这些电子所处的状态。这就将这个问题在理论上推上了一个新的高度。在古代，假如一个人和你谈论这个问题，你可以辩称构成自己的元素和构成他人的元素是不一样的，而身处现代的我们则失去了这一武器。如果说在古代这个哲学问题还仅仅是个思想实验，那在现代，则已经是一个实实在在的具有可行性的实验了，说不定在未来还会有人专门去做实验验证。

作为一个简单的思考，我们不妨先考虑一些容易的，可思辨的情景，比如同卵双胞胎，理论上说，同卵双胞胎的基因是几乎完全一样的，进一步的，他们的相貌、器官、特征几乎都完全一样，但是我们并不能认为他们是同一个人，因为显然他们的意识存在于两个不同的身体里，有着各自的时空连续性。同卵双胞胎的例子并不能进一步得到传送机器问题的答案，这是由于同卵双胞胎之间还是有区别的，并非完全一致，但是这有助于我们对这个问题进一步的思考，既然同卵双胞胎之间几乎完全一样的身体能容纳两个不同的意识，那么是否说明意识与身体之间毕竟不是完全等同的呢，或者说意识并不是完全由物质决定的呢？如果是这样，那么会有所谓的灵魂吗？

所谓灵魂，在我们看来就是一种非常特殊的东西，它不依附于物质而存在，甚至可以说是永存不灭的，它构成了我们意识的核心，是我们身份最本质的东西。遗憾的是，灵魂说目前并未被证实或者证伪，而且由于目前对于大脑的研究尚浅，估计有生之年也看不到被证实或证伪的希望了。而马克思认为，物质是意识的基础，物质决定意识，反过来意识对物质有能动作用。这里，马克思肯定了物质对意识的决定作用，也肯定了人类改造世界的能力，但并没有认同灵魂论，马克思认为意识依附于物质而存在，是无法脱离物质的。从自然科学的观点来看则很容易看待这个问题，我们可以做一些简单的思辨，比如：人类大脑的结构是非常复杂的，这正是意识产生的物质基础，从一方面来说，人类产生意识的原因就是大脑的复杂结构，而其他生物无法产生意识就是因为大脑结构不够复杂、容量不够大。另一方面来说，假如认同灵魂论，那么任何事物都能有意识产生，一块石头，只要有灵魂依附，就可以产生意识，这显然是不符合我们的经验的。自然科学有一原则，也可以对这个问题做一些指导。这就是奥卡姆剃刀原理：“如无必要，勿增实体。”假如同一现象可以由两种不同的理论解释，那么我们应该相信那种更简单的。在这里，灵魂就是两种观点不同的地方，灵魂作为一种我们无法认识和解释的事物，是我们原则上应该予以避免的。即如果我们无需灵魂就能解释意识，那么我们应当认为灵魂不存在。假如有一天我们彻底的认识了大脑的机理，知道了意识形成的原理，如果这和灵魂无关，那么我们也就不再需要灵魂了。

从自然科学的角度解释意识是更为简单而时髦的，但这同样会带来问题，一个例子就是著名的拉普拉斯妖，这是拉普拉斯假想的一个全知的妖魔，它能根据宇宙过往的状态计算出将来任意时刻的状态，人类在它面前毫无自由意志可言，因为我们的任何行动甚至是思想都是可预测的，彻彻底底的摧毁了自由意志这一说。同样，随着近代量子力学的发展，这一问题也有了新的发展，人们不再认同牛顿时代的决定论，不再认为从宇宙的初始状态可以计算出任意时刻的状态，而是由于量子的随机性，我们无法预测未来。混沌理论有个经典的蝴蝶效应一说，指在一个动力系统中，初始条件下微小的变化能引起整个系统长期而巨大的连锁反应，弗罗里达州的一只蝴蝶扇动一下翅膀，可以在德克萨斯州引起一场龙卷风。这当然解决了决定论的问题，至少我们知道我们的未来不是完全确定的了，但这仍然没有完全的解决我们的问题。从某种角度上说，这只是将我们的选择从物理规则丢给了一个扔骰子的“上帝”，所以我们其实仍然无法自主的作出决定，似乎只有承认灵魂的存在才能解决这个问题。对我个人而言，这其实是个非常痛苦的决定，一边是自己信奉的带给人类长足进步的自然科学，另一边则是自己的自由意志，仿佛自己的存在和自己信仰的东西是冲突的，两者之间存在无法协调的矛盾，处境堪比电视剧里处在婆媳斗争之间的男人。

作为我个人而言，我其实是认为灵魂不存在的，很不负责任的说，一个我们无法认识也无法理解的东西，其实跟我们没什么关系，我们也可以根本不关心它是否到底存在。目前来看，我们也的确没有必要为了解释意识而假定灵魂存在，随着脑科学的发展，我们会逐步加深对意识的认识，从而解释这个问题。从另一方面讲，我个人认为灵魂这个概念和宗教一样，其产生的原因是人类对于死亡的未知和恐惧。作为生物，为了更好的生存繁衍，我们有着刻在基因里的对死亡的恐惧，这既是我们前进的动力，也是我们的局限。作为一个唯物主义者，我看待这个问题其实是挺悲观的，因为在我看来，我们既无灵魂也无自由意志，也就没有改造这个世界的能力。应该来说，我的这些看法还是很幼稚不成熟的，随着以后科学的发展，应该可以对这些问题作出更好的回答。

最后回到我们一开始的问题，假如有这样一台传送机器，那么我是肯定不会用的，虽然我们假定有可能存在这样跟自己一模一样的个体，但毕竟从过程上来说，分解原来的自己就是杀死了自己。从这一点上来说，电影《致命魔术》里，其中一位魔术师的做法就显得尤为疯狂。

小谈GPL

2017-03-30T00:00:00Z

定义与现状

The GNU General Public License (GNU GPL or GPL) is a widely used free software license, which guarantees end users the freedom to run, study, share and modify the software.

GPL是一种被开源项目广泛采用的开源协议。目前GPL协议的最新版本为GPLv3，于2007年6月29日发布。根据BlackDuckKnowledgeBase的数据，GPL的v2和v3版本目前分别占全球开源项目采用协议的17.75%和7.47%，以下为具体图表。

img

采用GPL开源协议的著名开源项目有Linux kernel、Emacs、git等。

COPYLEFT

GPL最独特的地方莫过于其提出的Copyleft概念，这亦是GPL协议中的核心概念，这一概念目前并没有很好的中文翻译，目前一些常见的翻译有：著作传、著佐权、反版权、版权属左、脱离版权、版权所无、版权左派、公共版权、著作续、版责、版可等。

关于Copyleft的定义，我们可参见提出者Richard Stallman的文章《What is Copyleft?》

Copyleft is a general method for making a program (or other work) free (in the sense of freedom, not “zero price”), and requiring all modified and extended versions of the program to be free as well. Copyleft says that anyone who redistributes the software, with or without changes, must pass along the freedom to further copy and change it. Copyleft guarantees that every user has freedom.

Copyleft最主要的两个特性在于：

Copyleft保障任何用户使用、研究、发行、修改、公布此作品的权利。
Copyleft强制所有基于GPL协议开源的作品，其复制或衍生作品均使用GPL协议开源。

一个常见的关于Copyleft和GPL的误解是，如果一个作品采用GPL协议开源，那原作者就放弃了作品的版权。实际上GPL的Copyleft概念正是建立在Copyright上的，正是因为Copyright，才让Copyleft这一概念在法律上具有可行性，原作者并未放弃作品的版权，只是通过GPL协议赋予了其他人使用、研究、修改、发行等对该作品的权利。

Copyleft is a way of using of the copyright on the program. It doesn’t mean abandoning the copyright; in fact, doing so would make copyleft impossible. The “left” in “copyleft” is not a reference to the verb “to leave”—only to the direction which is the mirror image of “right”.

Liberty or Death

Free software 的定义如下：

A program is Free Software if you, the user, have these four freedoms: - Freedom zero is the freedom to run the program as you wish, for any purpose. - Freedom one is the freedom to study the source code and change it to make it do what you wish. - Freedom two is the freedom to help your neighbour, that’s the freedom to make copies and distribute them to others when you wish. - Freedom three is the freedom to help your community: the freedom to publish or distribute modified versions when you wish.

Copyleft这一概念实际上基于Free Software理念，其核心目的是知识共享。GPL协议试图达成一种人人贡献知识、人人收益于知识的理想环境，为了这个目的，则必须要求最大程度的知识共享。

因而在所有的开源协议中，GPL是对待开源最为严肃的。遵循着Free Software的理念，GPL要求用户在自己的项目中使用GPL的同时，必须开放源代码，而不仅仅是可执行的二进制文件，以便于他人的使用和研究、修改、发布。并且在发布任何基于GPL许可的软件时，不能添加任何限制性的条款。GPL协议还要求用户在发布基于或者包含使用GPL协议的开源项目的项目（或者说复制件和演绎项目）时，必须同样使用GPL协议，即必须开源且保障其他用户对该项目的权利。

在GPLv2中，Richard Stallman正式添加了“Liberty or Death”这一条款。

GPL的传染性

由于Copyleft强制所有基于GPL协议开源的作品，其复制或衍生作品均使用GPL协议的特性，GPL协议并不赋予使用者将衍生项目闭源或者封闭的权利，使得GPL协议具有非常强大的传染能力，因而也被一些人批评。2001年微软的CEO史蒂夫·鲍尔默称使用GPL协议的Linux为“癌症”，因为任何使用Linux kernel源代码的项目，均必须采用GPL协议开源。

GPL给予了计算机程序自由软件的定义，其设计哲学也处处遵循着自由软件的理念。与其他开源协议(诸如BSD协议、MIT协议、Apache协议)不同，GPL最大程度的确保项目是自由软件、而其他协议则最大限度的给予“所有人”最大的自由，包括闭源的自由。通常认为，GPL对于开源的态度过于极端，不如其他开源协议来的包容，因而在现在的开源项目协议中占比减小。

由于这一特性，一方面，GPL促进了许多项目的开源，同时鼓励更多人参与开源项目的开发，使得这些开源项目有了经久不衰的生命力，促进了开源事业的蓬勃发展。比如采用GPL协议的Linux kernel，尽管这个项目最初是Linus的个人项目，但随着发展，最终这个项目的代码里，仅有不到1%是出自Linus之手，其他的代码均来自世界各地的开发者，他们自发开发维护着Linux kernel，从而使得Linux生态茁壮成长。

另一方面，由于GPL对于闭源的不友好，而使很多闭源项目对使用GPL协议的开源项目敬而远之，这一方面，其实GPL又对开源产生了一些负面影响。于是GNU基金会又推出了一个相对宽松的LGPL协议，该协议允许衍生项目闭源，以期解决这个问题。同时，大部分的开源协议，均是GPL兼容的。

GPL的法律效力

2002 年，MySQL AB 公司起诉 Progress NuSphere 侵犯版权和商标。NuSphere 被指以链接代码的形式侵犯了著作权。最终此案以调解结束。在听证期间，法官 “认为没有什么原因”会使得 GPL 失去法律效力。

2003 年 8 月，SCO Group 称他们认为 GPL 没有法律效力，且准备就在 Linux 核心中使用的 SCO Unix 代码进行诉讼。

2004 年 4 月，在 SiteCom 拒绝停止发行 Netfilter 项目的 GPL 软件后，慕尼黑地区法庭据对 GPL 条款的侵犯判定对 SiteCom 进行临时性禁令（诉前停止侵犯专利权行为的措施）。同年 7 月，法庭确认此勒令为对 SiteCom 最终判决。此判决十分重要，因为它是全球首次法庭确认 GPL 是有法律效力的。

2005 年 5 月，Daniel Wallace于美国联邦印第安纳南区地方法院起诉自由软件基金会，因为二者对GPL是否是非法意见不一。后诉讼于3月结束，因为Wallace没有有效的反托拉斯陈述。法庭注意到“GPL鼓励，而不是反对电脑操作系统的自由竞争和发行，这直接使消费者受益。” Wallace被拒绝改变诉由，并被要求支付诉讼费用。

相似来源协议

LGPL，全称“GNU宽通用公共许可证（英语：GNU Lesser General Public License）”，它允许企业与软件开发者使用，或将 LGPL 授权的软件集成至他们自己的软件内（即使该软件是私有软件也被允许），同时不会受到 Copyleft 特性的许可证强制对软件开源的限制。

WTFPL（Do What The Fuck You Want To Public License，中文译名：你他妈的想干嘛就干嘛公共许可证）是一种不太常用的、极度放任的自由软件许可证。它的条款基本等同于贡献到公有领域。

小结

开源or闭源是软件开发里经久不衰的话题，就像vim vs emacs或者tab vs space或者大括号换行不换行一样，是程序员们津津乐道的话题之一。

作为GNU项目的发起者，Richard Stallman发起GPL协议的目的是知识共享，旨在营造人人参与人人收益的环境。秉承着自由软件的理念，GPL协议鼓励人们与他人共享自己的成果，并确保这成果的发展不会被据为私有。

由于其对于开源的极致追求，GPL协议在全球计算机发展中起到了无可替代的作用，产生了巨大而深远的影响，极大的促进了开源事业的发展。

我个人对GPL协议很感兴趣，与其他更为宽松的开源协议相比，GPL协议选择了对开源的极致追求，而排斥闭源，从而使得GPL协议具有其他协议所不具备的传染能力。假如一个商业闭源项目需要使用一个以GPL协议开源的项目，那么他们就必须开源自己的项目，否则就必须自己重新造轮子或者找其他替代品。GPL协议确保了开发者的工作仅会对开源项目做出贡献。

在当前时代，知识共享是时代的大趋势。版权作为技术知识快速发展的环境下的产物，对于保护作者对于该知识产权的权利起到了非常积极的作用，它使得原作者的权利不会被其他人所侵犯，但同时也不可避免的阻碍了知识共享的过程。为了解决这一问题，Copyleft赋予了其他人与原作者对于该作品几乎等同的权利。我个人认为，Copyright看似来是Copyright的对立面，实则是对Copyright的补充与发展。

由于其极端性，GPL协议不可避免的受到了诸多批评，但我认为，由于作者本身有选择使用何种开源协议的自由，所以如果作者本身愿意自己的作品被闭源项目使用，则可以使用其他相对宽松的开源协议。所以GPL协议本身并不是作品成为”cancer”的原因，GPL仅仅是为作者提供了一种更为极端的开源选择。

References

wikipedia: GPL https://en.wikipedia.org/wiki/GNU_General_Public_License#cite_note-blackduck2015-6
*维基中文:GNU通用公共许可协议 https://zh.wikipedia.org/wiki/GNU%E9%80%9A%E7%94%A8%E5%85%AC%E5%85%B1%E8%AE%B8%E5%8F%AF%E8%AF%81
Top Open Source Licenses - Black Duck Software https://www.blackducksoftware.com/top-open-source-licenses
《什么是COPYLEFT?》 Richard Stallman https://www.gnu.org/copyleft/copyleft.html
《What is Copyleft?》 Richard Stallman https://www.gnu.org/licenses/copyleft.html.en
维基中文: Copyleft https://zh.wikipedia.org/wiki/Copyleft
wikipedia: Copyleft https://en.wikipedia.org/wiki/Copyleft
维基中文：自由软件 https://zh.wikipedia.org/wiki/%E8%87%AA%E7%94%B1%E8%BD%AF%E4%BB%B6
GPLv3: Transcript of Richard Stallman at the 2nd international GPLv3 conference ; 21st April 2006 https://fsfe.org/campaigns/gplv3/fisl-rms-transcript.en.html
维基中文： GNU宽通用公共许可证 https://zh.wikipedia.org/wiki/GNU%E5%AE%BD%E9%80%9A%E7%94%A8%E5%85%AC%E5%85%B1%E8%AE%B8%E5%8F%AF%E8%AF%81
维基中文： WTFPL https://zh.wikipedia.org/wiki/WTFPL
阮一峰: 为什么 GPL 是更好的开源许可证? http://www.ruanyifeng.com/blog/2010/02/why_gpl_is_a_better_choice.html

Q-learning

2017-02-25T00:00:00Z

用Q-learning算法做一个Flappy Bird的AI这个想法是来自zhihu的一个回答，觉得很有趣，就自己尝试着实现了。

Q-learning是强化学习的一种算法，他将我们需要强化的对象抽象成State和Action，我们的智能体Agent，将根据State，决定所采取的Action，从而得到新的State’，根据新的State’，我们将更新旧的State的策略，我们称之为Reward。

举Flappy Bird的例子来说，我们可以定义State为小鸟和下一个管道的坐标之差(dx, dy)

当然，也可以将垂直速度也加入进来(dx, dy, speed)一起构成State

而对于每个状态，小鸟能采取的Action都只有两个，跳or不跳。

而我们用一张表来记录我们采取的策略，这张表其实就是我们Agent的大脑，记为Q（实际上在术语里被称为动作效应函数）:

对于特定的State，我们可以选择表中值较大的那栏作为Action（当然还有不同的选择方法，比如为了充分探索的 $𝜖 - 𝑔 𝑟 𝑒 𝑒 𝑑 𝑦$ 策略）

根据Action之后状态的不同，我们将给予Agent不同的Reward，即根据State’来更新表中对应State和Action的值。

具体公式如下:

这里的s代表State,a代表Action，Q(s,a)即State下选择的Action对应的Q表里的值， $𝛼$ 是学习速率，取(0,1)之间，越大则学习的越快，也越容易丢失之前学习的效果。r是我们选择给予的Reward，以我自己的例子来说，是死亡的时候给予-1000，活着给1，得分给42.75， ${max}_{𝑎^{'}} 𝑄 (𝑠^{'}, 𝑎^{'})$ 则是我们在新的State’下能够得到的最大的利益（准确的说是我们记忆中能得到的最大利益）， $𝛾$ 是一个常数，越大则代表我们越重视潜在利益或者说以往的经验。

游戏里的每一帧，我们都重复迭代进行这个过程，直到我们得到一个满意的模型。

可以用以下伪代码来表示:

initialize Q
repeat
    initialize S
    repeat until dead
        choose Action A depend on S and Q
        Get S' depend on S and A
        Get r depend on S'
        Q(S,A) <- Q(S,A)+α(r+γmaxQ(S',A')-Q(S,A))
        S <- S'

由于中了OOP的毒，我已经没办法驾驭自己写的代码了，所以这个项目就暂时到此为止吧，至少自己的主要目的还是达到了。（逃

Fibonacci

2017-02-20T00:00:00Z

算了，今天不想动那只笨鸟了，写点别的吧。

大名鼎鼎的斐波那契数列，定义非常简单:

先不急着写代码，我们先来求一下这个数列的通项公式。为了方便先用符号 $𝑎_{𝑛}$ 来表示。

先把上式写成如下形式，这样则 $𝑎_{𝑛} - 𝜇 𝑎_{𝑛 - 1}$ 是一个等比数列，我们可以求出它的通项：

所以有:

故 $𝛾$ 和 $𝜇$ 是以下方程的两个根:

由求根公式，求得:

取 $𝛾 = \frac{1 + \sqrt{5}}{2}, 𝜇 = \frac{1 - \sqrt{5}}{2}$ ，有:

令 $𝑏_{𝑛} = 𝑎_{𝑛 + 1} - \frac{1 - \sqrt{5}}{2} 𝑎_{𝑛}$ ，则可知:

故:

两边同时除以 ${(\frac{1 - \sqrt{5}}{2})}^{𝑛 + 1}$ 有:

令 $𝑐_{𝑛} = \frac{𝑎_{𝑛}}{{(\frac{1 - \sqrt{5}}{2})}^{𝑛}}$ ，有:

故:

由等比数列求和公式有:

故:

可以看到Fibonacci数列大致上是按指数级别增长的，且n越大，前后两项的比值越趋近黄金分割比 $\frac{\sqrt{5} - 1}{2}$

回到代码，大体上来说求Fibonacci数列的方法主要用三种：递归法、循环法、我也不知道叫什么法就暂时叫它矩阵法好了（反正不是基本法，逃

三种方法有着不同的时间复杂度

递归法:

function rst = fib(n)
if n < 3
    rst = 1;
else
    rst = fib(n-1) + fib(n-2);
end

直观上来说，由于递归法的递归树最终的叶都是计算fib(1)，所以递归法的时间复杂度就是Fibonacci数列的值。即递归法的时间复杂度是指数级别的。当然我们可以用空间换时间的办法来把递归法的时间复杂度变成线性级别。也可以称为数组法= =

循环法:

function rst = fib(n)
rst = 1;
t1 = 1;
t2 = 0;
count = 0;
while count < n - 1
    rst = t1 + t2;
    t2 = t1;
    t1 = rst;
    count = count + 1;
end

循环法时间复杂度是线性的，空间复杂度是常数级别的。

有的时候我们会觉得线性时间复杂度还不够好，那怎么办呢，到了矩阵法出场的时候了，不过先别着急，先来介绍一个相关的算法:快速幂算法。

假如你要计算a的n次方，那么我们一般会循环n次，每次结果都乘a。

而快速幂算法则不一样，这个方法用递归的方式来计算，具体来说递归的每步是这样的:

假如n=1，则返回a
假如n为偶数，计算 $𝑎^{{(𝑛 / 2)}^{2}}$
假如n为奇数，计算 $𝑎^{{((𝑛 - 1) / 2)}^{2}} \times 𝑎$

很容易知道快速幂算法的时间复杂度是对数级别的，而且这里的a并不限于是实数，可以是复数、矩阵等。而有了这个算法，就可以介绍矩阵法的做法了。

矩阵法:

来观察以下矩阵

可能观察不出什么来，但是我们可以很容易的得到以下等式:

so on

实际上，一般情况为:

可以用数学归纳法证明:

为了方便起见，我们从n=2开始证明，很显然n=2是成立的。

假设n=k时，成立

则当n=k+1时

得证

由于做一次[2x2]矩阵的乘法是常数级别时间复杂度的，所以我们可以通过矩阵+快速幂算法，来实现一个时间复杂度为对数级别的算法来求Fibonacci数列。

代码如下:

function rst = fib(n)
temp = [0,1;1,1]^n;
rst = temp(1,2);

所以你看，用了matlab世界瞬间变得简单了~

后记:所有的代码均不考虑n=0或n为负数的情况。曾经年少（15年复读那会吧）的我想过，既然通项公式已经知道了，直接求不就好了，而且我确实还写了代码。当然其实因为浮点数的精度问题，这样做肯定是免不了有问题的，而且即使如此，由于通项公式里有n次方，所以实际上到头来你最好的时间复杂度还是对数级别的，何必呢。这里我的矩阵法matlab代码里，并没有体现快速矩阵幂这一点，这是因为matlab的矩阵求幂算法肯定比我手动实现快速矩阵幂快（逃

当然还要补充的是，实际上由于Fibonacci数列的指数级增长，所以对于大多数编程语言来说，Gibonacci数列的项会比较快的突破整数or浮点数的表示范围，所以，这个问题一般实际上意义不大的。另外Fibonacci数列有很多有趣的性质，这里就不再展开讨论了。