feat: add new lcp problems

Author: yanglbme

lcp/LCP 77. 符文储备/README.md

@@ -0,0 +1,65 @@
+# [LCP 77. 符文储备](https://leetcode.cn/problems/W2ZX4X)
+
+## 题目描述
+
+<!-- 这里写题目描述 -->
+
+远征队在出发前需要携带一些「符文」，作为后续的冒险储备。`runes[i]` 表示第 `i` 枚符文的魔力值。
+
+他们将从中选取若干符文进行携带，并对这些符文进行重新排列，以确保任意相邻的两块符文之间的魔力值相差不超过 `1`。
+
+请返回他们能够携带的符文 **最大数量**。
+
+**示例 1：**
+
+> 输入：`runes = [1,3,5,4,1,7]`
+>
+> 输出：`3`
+>
+> 解释：最佳的选择方案为[3,5,4]
+> 将其排列为 [3,4,5] 后，任意相邻的两块符文魔力值均不超过 `1`，携带数量为 `3`
+> 其他满足条件的方案为 [1,1] 和 [7]，数量均小于 3。
+> 因此返回可携带的最大数量 `3`。
+
+**示例 2：**
+
+> 输入：`runes = [1,1,3,3,2,4]`
+>
+> 输出：`6`
+>
+> 解释：排列为 [1,1,2,3,3,4]，可携带所有的符文
+
+**提示：**
+
+-   `1 <= runes.length <= 10^4`
+-   `0 <= runes[i] <= 10^4`
+
+## 解法
+
+<!-- 这里可写通用的实现逻辑 -->
+
+<!-- tabs:start -->
+
+### **Python3**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```python
+
+```
+
+### **Java**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```java
+
+```
+
+### **...**
+
+```
+
+```
+
+<!-- tabs:end -->

lcp/LCP 78. 城墙防线/README.md

@@ -0,0 +1,73 @@
+# [LCP 78. 城墙防线](https://leetcode.cn/problems/Nsibyl)
+
+## 题目描述
+
+<!-- 这里写题目描述 -->
+
+在探险营地间，小扣意外发现了一片城墙遗迹，在探索期间，却不巧遇到迁徙中的兽群向他迎面冲来。情急之下小扣吹响了他的苍蓝笛，随着笛声响起，遗迹中的城墙逐渐发生了横向膨胀。
+已知 `rampart[i] = [x,y]` 表示第 `i` 段城墙的初始所在区间。当城墙发生膨胀时，将遵循以下规则：
+
+-   所有的城墙会同时膨胀相等的长度；
+-   每个城墙可以向左、向右或向两个方向膨胀。
+
+小扣为了确保自身的安全，需要在所有城墙均无重叠的情况下，让城墙尽可能的膨胀。请返回城墙可以膨胀的 **最大值** 。
+
+**注意：**
+
+-   初始情况下，所有城墙均不重叠，且 `rampart` 中的元素升序排列；
+-   两侧的城墙可以向外无限膨胀。
+
+**示例 1：**
+
+> 输入：`rampart = [[0,3],[4,5],[7,9]]`
+>
+> 输出：`3`
+>
+> 解释：如下图所示：
+> `rampart[0]` 向左侧膨胀 3 个单位；
+> `rampart[2]` 向右侧膨胀 3 个单位；
+> `rampart[1]` 向左侧膨胀 1 个单位，向右膨胀 2 个单位。
+> 不存在膨胀更多的方案，返回 3。
+> ![image.png](https://fastly.jsdelivr.net/gh/doocs/leetcode@main/lcp/LCP%2078.%20%E5%9F%8E%E5%A2%99%E9%98%B2%E7%BA%BF/images/1681717918-tWywrp-image.png){:width=750px}
+
+**示例 2：**
+
+> 输入：`rampart = [[1,2],[5,8],[11,15],[18,25]]`
+>
+> 输出：`4`
+
+**提示：**
+
+-   `3 <= rampart.length <= 10^4`
+-   `rampart[i].length == 2`
+-   `0 <= rampart[i][0] < rampart[i][1] <= rampart[i+1][0] <= 10^8`
+
+## 解法
+
+<!-- 这里可写通用的实现逻辑 -->
+
+<!-- tabs:start -->
+
+### **Python3**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```python
+
+```
+
+### **Java**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```java
+
+```
+
+### **...**
+
+```
+
+```
+
+<!-- tabs:end -->

lcp/LCP 78. 城墙防线/images/1681717918-tWywrp-image.png

@@ -0,0 +1,69 @@
+# [LCP 79. 提取咒文](https://leetcode.cn/problems/kjpLFZ)
+
+## 题目描述
+
+<!-- 这里写题目描述 -->
+
+随着兽群逐渐远去，一座大升降机缓缓的从地下升到了远征队面前。借由这台升降机，他们将能够到达地底的永恒至森。
+在升降机的操作台上，是一个由魔法符号组成的矩阵，为了便于辨识，我们用小写字母来表示。 `matrix[i][j]` 表示矩阵第 `i` 行 `j` 列的字母。该矩阵上有一个提取装置，可以对所在位置的字母提取。
+提取装置初始位于矩阵的左上角 `[0,0]`，可以通过每次操作移动到上、下、左、右相邻的 1 格位置中。提取装置每次移动或每次提取均记为一次操作。
+
+远征队需要按照顺序，从矩阵中逐一取出字母以组成 `mantra`，才能够成功的启动升降机。请返回他们 **最少** 需要消耗的操作次数。如果无法完成提取，返回 `-1`。
+
+**注意：**
+
+-   提取装置可对同一位置的字母重复提取，每次提取一个
+-   提取字母时，需按词语顺序依次提取
+
+**示例 1：**
+
+> 输入：`matrix = ["sd","ep"], mantra = "speed"`
+>
+> 输出：`10`
+>
+> 解释：如下图所示
+> ![矩阵 (2).gif](<https://fastly.jsdelivr.net/gh/doocs/leetcode@main/lcp/LCP%2079.%20%E6%8F%90%E5%8F%96%E5%92%92%E6%96%87/images/1646288670-OTlvAl-%E7%9F%A9%E9%98%B5%20(2).gif>)
+
+**示例 2：**
+
+> 输入：`matrix = ["abc","daf","geg"]， mantra = "sad"`
+>
+> 输出：`-1`
+>
+> 解释：矩阵中不存在 `s` ，无法提取词语
+
+**提示：**
+
+-   `0 < matrix.length, matrix[i].length <= 100`
+-   `0 < mantra.length <= 100`
+-   `matrix 和 mantra` 仅由小写字母组成
+
+## 解法
+
+<!-- 这里可写通用的实现逻辑 -->
+
+<!-- tabs:start -->
+
+### **Python3**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```python
+
+```
+
+### **Java**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```java
+
+```
+
+### **...**
+
+```
+
+```
+
+<!-- tabs:end -->

lcp/LCP 79. 提取咒文/README.md

@@ -0,0 +1,72 @@
+# [LCP 80. 生物进化录](https://leetcode.cn/problems/qoQAMX)
+
+## 题目描述
+
+<!-- 这里写题目描述 -->
+
+在永恒之森中，存在着一本生物进化录，以 **一个树形结构** 记载了所有生物的演化过程。经过观察并整理了各节点间的关系，`parents[i]` 表示编号 `i` 节点的父节点编号(根节点的父节点为 `-1`)。
+
+为了探索和记录其中的演化规律，队伍中的炼金术师提出了一种方法，可以以字符串的形式将其复刻下来，规则如下：
+
+-   初始只有一个根节点，表示演化的起点，依次记录 `01` 字符串中的字符，
+-   如果记录 `0`，则在当前节点下添加一个子节点，并将指针指向新添加的子节点；
+-   如果记录 `1`，则将指针回退到当前节点的父节点处。
+
+现在需要应用上述的记录方法，复刻下它的演化过程。请返回能够复刻演化过程的字符串中， **字典序最小** 的 `01` 字符串。
+
+**注意：**
+
+-   节点指针最终可以停在任何节点上，不一定要回到根节点。
+
+**示例 1：**
+
+> 输入：`parents = [-1,0,0,2]`
+>
+> 输出：`"00110"`
+>
+> 解释：树结构如下图所示，共存在 2 种记录方案：
+> 第 1 种方案为：0(记录编号 1 的节点) -> 1(回退至节点 0) -> 0(记录编号 2 的节点) -> 0((记录编号 3 的节点))
+> 第 2 种方案为：0(记录编号 2 的节点) -> 0(记录编号 3 的节点) -> 1(回退至节点 2) -> 1(回退至节点 0) -> 0(记录编号 1 的节点)
+> 返回字典序更小的 `"00110"`
+> ![image.png](https://fastly.jsdelivr.net/gh/doocs/leetcode@main/lcp/LCP%2080.%20%E7%94%9F%E7%89%A9%E8%BF%9B%E5%8C%96%E5%BD%95/images/1682319485-cRVudI-image.png){:width=120px}![进化 (3).gif](<https://fastly.jsdelivr.net/gh/doocs/leetcode@main/lcp/LCP%2080.%20%E7%94%9F%E7%89%A9%E8%BF%9B%E5%8C%96%E5%BD%95/images/1682412701-waHdnm-%E8%BF%9B%E5%8C%96%20(3).gif>){:width=320px}
+
+**示例 2：**
+
+> 输入：`parents = [-1,0,0,1,2,2]`
+>
+> 输出：`"00101100"`
+
+**提示：**
+
+-   `1 <= parents.length <= 10^4`
+-   `-1 <= parents[i] < i` (即父节点编号小于子节点)
+
+## 解法
+
+<!-- 这里可写通用的实现逻辑 -->
+
+<!-- tabs:start -->
+
+### **Python3**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```python
+
+```
+
+### **Java**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```java
+
+```
+
+### **...**
+
+```
+
+```
+
+<!-- tabs:end -->

lcp/LCP 79. 提取咒文/images/1646288670-OTlvAl-矩阵 (2).gif

@@ -0,0 +1,91 @@
+# [LCP 81. 与非的谜题](https://leetcode.cn/problems/ryfUiz)
+
+## 题目描述
+
+<!-- 这里写题目描述 -->
+
+在永恒之森中，封存着有关万灵之树线索的卷轴，只要探险队通过最后的考验，便可以获取前往万灵之树的线索。
+
+探险队需要从一段不断变化的谜题数组中找到最终的密码，初始的谜题为长度为 `n` 的数组 `arr`（下标从 0 开始），数组中的数字代表了 `k` 位二进制数。
+破解谜题的过程中，需要使用 `与非（NAND）` 运算方式，`operations[i] = [type,x,y]` 表示第 `i` 次进行的谜题操作信息：
+
+-   若 `type = 0`，表示修改操作，将谜题数组中下标 `x` 的数字变化为 `y`；
+-   若 `type = 1`，表示运算操作，将数字 `y` 进行 `x*n` 次「与非」操作，第 `i` 次与非操作为 `y = y NAND arr[i%n]`；
+    > 运算操作结果即：`y NAND arr[0%n] NAND arr[1%n] NAND arr[2%n] ... NAND arr[(x*n-1)%n]`
+
+最后，将所有运算操作的结果按顺序逐一进行 `异或（XOR）`运算，从而得到最终解开封印的密码。请返回最终解开封印的密码。
+
+**注意:**
+
+-   「与非」（NAND）的操作为：先进行 `与` 操作，后进行 `非` 操作。
+    > 例如：两个三位二进制数`2`和`3`，其与非结果为 `NOT ((010) AND (011)) = (101) = 5`
+
+**示例 1：**
+
+> 输入:
+> `k = 3` > `arr = [1,2]` > `operations = [[1,2,3],[0,0,3],[1,2,2]]`
+>
+> 输出: `2`
+>
+> 解释：
+> 初始的谜题数组为 [1,2]，二进制位数为 3，
+> 第 0 次进行运算操作，将数字 3(011) 进行 2\*2 次「与非」运算，
+> 运算操作结果为 `3 NAND 1 NAND 2 NAND 1 NAND 2 = 5`
+> 第 1 次进行修改操作，谜题数组的第 `0` 个数字变化为 `3`，谜题变成 `[3,2]`
+> 第 2 次进行运算操作，将数字 2(010) 进行 2\*2 次「与非」运算，
+> 运算操作结果为 `2 NAND 3 NAND 2 NAND 3 NAND 2 = 7`
+> 所有运算操作结果进行「异或」运算为 `5 XOR 7 = 2`
+> 因此得到的最终密码为 `2`。
+
+**示例 2：**
+
+> 输入:
+> `k = 4` > `arr = [4,6,4,7,10,9,11]` > `operations = [[1,5,7],[1,7,14],[0,6,7],[1,6,5]]`
+> 输出: `9`
+> 解释:
+> 初始的谜题数组为 [4,6,4,7,10,9,11],
+> 第 0 次进行运算操作，运算操作结果为 5；
+> 第 1 次进行运算操作，运算操作结果为 5；
+> 第 2 次进行修改操作，修改后谜题数组为 [4, 6, 4, 7, 10, 9, 7]；
+> 第 3 次进行运算操作，运算操作结果为 9；
+> 所有运算操作结果进行「异或」运算为 `5 XOR 5 XOR 9 = 9`；
+> 因此得到的最终密码为 `9`。
+
+**提示:**
+
+-   `1 <= arr.length, operations.length <= 10^4`
+-   `1 <= k <= 30`
+-   `0 <= arr[i] < 2^k`
+-   若 `type = 0`，`0 <= x < arr.length` 且 `0 <= y < 2^k`
+-   若 `type = 1`，`1 <= x < 10^9` 且 `0 <= y < 2^k`
+-   保证存在 `type = 1` 的操作
+
+## 解法
+
+<!-- 这里可写通用的实现逻辑 -->
+
+<!-- tabs:start -->
+
+### **Python3**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```python
+
+```
+
+### **Java**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```java
+
+```
+
+### **...**
+
+```
+
+```
+
+<!-- tabs:end -->