heky 发布的文章

Trie 树,亦称前缀树,是一种高效处理字符串的基础数据结构。许多算法问题中,Trie 树因其能快速检索字符串的前缀匹配而备受青睐。

在本文中,我们将从 Trie 树的基本插入与查询操作出发,详解为何节点编号 p 不会被限制在 26 个以内。

1. Trie 树的基本结构

Trie 树通常用于处理一组字符串,每个节点代表一个前缀。Trie 树的每个节点最多有 26 个子节点,分别对应小写字母 az

插入操作

以下是 Trie 树的典型插入代码:

void insert(char str[])  
{  
    int p = 0;  // 从根节点开始遍历  
    for (int i = 0; str[i]; i++) // 沿着字符串的每个字符进行遍历  
    {  
        int j = str[i] - 'a';  // 将字符映射为 0 ~ 25 的整数  
        if (!son[p][j]) son[p][j] = ++idx;  // 如果该子节点不存在,则创建新节点  
        p = son[p][j];  // 移动到下一个节点  
    }  
    cnt[p]++;  // 记录该字符串出现的次数  
}

在上述代码中,p 代表当前遍历到的节点编号,而 j = str[i] - 'a' 则将字符映射为相应的索引值,范围为 0 到 25,分别对应 az 的 26 个字母。

查询操作

查询一个字符串是否存在于 Trie 树中的代码如下:

bool search(char str[])  
{  
    int p = 0;  // 从根节点开始  
    for (int i = 0; str[i]; i++)  // 遍历字符串的每个字符  
    {  
        int j = str[i] - 'a';  // 计算字符的索引  
        if (!son[p][j]) return 0;  
        p = son[p][j];  // 移动到下一个节点  
    }  
    return cnt[p];  
}

p 是节点编号,不是字符索引

p 是 Trie 树中节点的编号,它表示当前遍历到的节点。虽然每个节点最多有 26 个子节点(对应字母 az),但 p 的值会随着 Trie 树的扩展而不断增加。p 代表的是节点编号,而不是字符范围。

2. 为什么 p 不会被限制在 26?

很多人可能疑惑,既然每个节点最多有 26 个子节点(分别对应字母 az),那么为什么 p 的值不会被限制在 26 个以内呢?

关键在于节点数量的动态扩展

Trie 树的每个节点最多有 26 个分支,但节点的总数却不限于 26。不同字符串的前缀可能会产生不同的节点,因此节点数量会根据插入的字符串的数量和内容动态增长。每当插入一个新字符串,如果某个字符的节点不存在,都会创建一个新的节点,并分配一个新的编号。

例如:

  • 插入字符串 "apple" 时,p 将沿着字符路径 "a" -> "p" -> "p" -> "l" -> "e" 移动,并为每个新字符创建一个新节点。
  • 每创建一个新节点时,节点编号 p 会递增,而不仅仅是 0 到 25 之间的固定值。
  • 因此,随着插入字符串数量的增加,Trie 树中的节点数量可以轻松超过 26,p 也会相应地增大。

3. Trie 树节点扩展的示例

假设我们插入三个不同的字符串:"apple""app""bat"。Trie 树的扩展情况如下:

  1. 插入 "apple"

    • a -> 新建节点(编号 1)
    • p -> 新建节点(编号 2)
    • p -> 新建节点(编号 3)
    • l -> 新建节点(编号 4)
    • e -> 新建节点(编号 5)
  2. 插入 "app"

    • 由于 "app""apple" 共享前缀 "app",只需沿着现有节点移动即可,不创建新节点。
  3. 插入 "bat"

    • b -> 新建节点(编号 6)
    • a -> 新建节点(编号 7)
    • t -> 新建节点(编号 8)

最终,节点 p 的最大编号会达到 8,而不是 26。这是因为每插入一个新字符串,都会动态扩展树的节点数量。

4. 总结

通过对 Trie 树插入和查询操作的讲解,我们可以得出以下结论:

  • 节点编号 p 表示当前遍历的节点,不是字符索引。
  • 节点数量根据插入的字符串数量动态增长,虽然每个节点的子节点数目被限制为 26,但节点的总数是根据需要不断扩展的,因此节点编号 p 也会随之增长。
  • Trie 树是一种高效的字符串存储和检索结构,非常适合前缀匹配和大规模字符串数据处理场景。

如果你在学习算法的过程中遇到类似的疑问或困惑,不妨从基础概念入手,逐步理解数据结构的设计原理。Trie 树作为一个经典的算法问题,值得深入理解与应用。

Knuth-Morris-Pratt (KMP) 算法是一种高效的字符串匹配算法,它用于在一个文本串中搜索模式串的所有出现。与暴力匹配算法不同,KMP通过预处理步骤来避免不必要的比较,从而提高效率。在这篇博客中,我们将详细探讨KMP的工作原理、ne数组的构建过程,以及回退在算法中的关键作用。


目录

  1. 字符串匹配介绍
  2. KMP算法概述
  3. ne数组(部分匹配表)
  4. 逐步示例
  5. get_next函数:构建ne数组
  6. KMP匹配过程
  7. 回退示例
  8. 总结

1. 字符串匹配介绍

字符串匹配是计算机科学中的一个常见问题,即需要在给定的文本串 s 中找到模式串 p 的所有出现。暴力匹配算法通过逐字符比较,但这种方法在面对长字符串时效率低下。KMP算法通过避免冗余比较来提高效率,而这一切都归功于 ne 数组(部分匹配表)的预处理。


2. KMP算法概述

KMP算法分为两个阶段:

  1. 预处理阶段:构建模式串 pne 数组(部分匹配表)。
  2. 匹配阶段:利用 ne 数组在文本 s 中搜索模式串 p,当出现不匹配时,通过 ne 数组回退,避免重复比较。

关键概念:

  • ne 数组:记录模式串中每个位置的最长相等前缀和后缀的长度。
  • 回退(Retreating):当发生不匹配时,利用 ne 数组让模式串回退到之前已经匹配的部分,而不是从头重新开始匹配。

3. ne数组(部分匹配表)

ne 数组是 KMP 算法的核心,它记录了模式串中每个位置最长相等前缀和后缀的长度。

假设模式串 p = "ABABC",我们通过以下步骤构建 ne 数组:

逐步计算:

  1. 对于 p[1] = A,没有前缀或后缀,所以 ne[1] = 0
  2. 对于 p[2] = B,与 p[1] = A 不匹配,因此 ne[2] = 0
  3. 对于 p[3] = A,与 p[1] = A 匹配,因此 ne[3] = 1
  4. 对于 p[4] = B,与 p[2] = B 匹配,因此 ne[4] = 2
  5. 对于 p[5] = C,与 p[3] = A 不匹配,所以回退到 ne[4],最终 ne[5] = 0

最终的 ne 数组为 [0, 0, 1, 2, 0]


4. 逐步示例

示例:

让我们通过一个具体的例子来演示如何计算 ne 数组,对于模式串 p = "ABABC"

  1. i = 2 开始,比较 p[2] = Bp[1] = A不匹配,所以 ne[2] = 0
  2. 移动到 i = 3,比较 p[3] = Ap[1] = A匹配,所以 ne[3] = 1
  3. 移动到 i = 4,比较 p[4] = Bp[2] = B匹配,所以 ne[4] = 2
  4. i = 5 时,比较 p[5] = Cp[3] = A不匹配。因此我们使用 ne[4] = 2 回退,比较 p[5] = Cp[2] = B仍不匹配,所以 ne[5] = 0

这显示了如何通过回退避免从头开始匹配。


5. get_next函数:构建ne数组

get_next 函数用于构建 ne 数组。以下是函数代码及其解释:

void get_next() {  
    for (int i = 2, j = 0; i <= n; i++) {  // 从模式串的第2个字符开始  
        while (j && p[i] != p[j + 1]) j = ne[j];  // 当字符不匹配时,回退j  
        if (p[i] == p[j + 1]) j++;  // 如果匹配成功,j前进  
        ne[i] = j;  // 存储当前i位置的最长相等前后缀长度  
    }  
}
  • 解释

    • i 从模式串的第二个字符开始遍历。
    • p[i] != p[j + 1] 时,使用 ne[j] 回退 j
    • 当匹配成功时,j 增加,并更新 ne[i] 的值。
    • 该过程会一直持续到构建完整的 ne 数组。

6. KMP匹配过程

一旦我们构建了 ne 数组,KMP的匹配过程就可以高效地进行。具体步骤如下:

  1. 我们将模式串 p 与文本 s 进行比较。
  2. 如果字符匹配,两个指针(i 用于文本,j 用于模式串)同时前进。
  3. 如果出现不匹配,使用 ne 数组回退 j,而不需要重新设置 i
void kmp() {  
    for (int i = 1, j = 0; i <= m; i++) {  // 遍历主串  
        while (j && s[i] != p[j + 1]) j = ne[j];  // 当不匹配时,回退 j  
        if (s[i] == p[j + 1]) j++;  // 如果匹配,继续前进  
        if (j == n) {  // 如果模式串全部匹配完成  
            printf("%d ", i - n);  // 输出匹配起始位置  
            j = ne[j];  // 回退 j,寻找下一个可能的匹配  
        }  
    }  
}

关键点:

  • 当发生不匹配时,我们通过 ne 数组回退 j,避免从头开始匹配。
  • 与暴力匹配相比,这种方法显著提升了效率。

7. 回退示例

让我们使用文本 s = "ABABDABACDABABC" 和模式串 p = "ABABC" 来展示回退的实际操作:

  1. 开始时,s[1] = Ap[1] = A 匹配。
  2. 继续匹配 s[2] = Bp[2] = B,匹配成功。
  3. 直到 s[5] = Dp[5] = C 不匹配。
  4. 通过 ne[4] = 2,我们回退到 p[3] = A,然后与 s[5] = D 比较,仍然不匹配。
  5. 最终回退到 ne[2] = 0,重新从 p[1] 开始。

这一过程展示了如何利用回退机制避免不必要的比较。


8. 总结

KMP算法是一种高效的字符串匹配算法,通过预处理 ne 数组,在匹配过程中避免从头重新比较。ne 数组帮助记录最长相等前后缀的长度,回退的使用大大提升了匹配效率。


通过对 ne 数组的理解和使用,KMP算法能够极大提高字符串匹配的效率。希望本篇博客能够帮助你掌握KMP算法的核心思想并能够应用到实际项目中。

在日常编程中,当我们计算非常大的数时,普通的整型数据类型无法处理这种情况下的运算。在这种情况下,我们需要使用高精度大数乘法算法来进行计算。本文将带你深入了解大数乘法的原理、如何逐位计算以及如何正确处理进位问题。

1. 什么是高精度大数乘法?

高精度大数乘法就是处理那些超出基本数据类型(如 intlong long)表示范围的数值的乘法运算。对于这类大数,由于其位数太多,我们不能直接进行运算,因此需要将其存储为数组,按位进行计算,最后处理进位并输出结果。

2. 高精度乘法的基本思想

高精度乘法的基本思想是模仿手工乘法的过程。我们将两个大数逐位相乘,然后逐位累加乘积,并对乘积结果进行进位处理。具体步骤如下:

2.1 手工乘法示例

假设我们有两个数字 a = 456b = 123,手工计算它们的乘积时,我们会这样做:

     456
×    123
--------
    1368   (456 × 3)
+   912    (456 × 2,向左移一位)
+  456     (456 × 1,向左移两位)
--------
  56088

我们先将 456 逐位乘以 123 的每一位,再将结果进行累加,最后得到结果 56088

2.2 高精度乘法的代码实现

在代码中,我们会将大数存储为数组的形式,每个数组元素表示一个数位。然后逐位相乘,并将每一步的结果累加到结果数组的相应位置上。为了方便理解,我们可以这样表示:

  • 数字 456 用数组表示为 a[] = {6, 5, 4}(从低位到高位存储)。
  • 数字 123 用数组表示为 b[] = {3, 2, 1}

乘法计算的步骤就是遍历这两个数组,逐位相乘,并将乘积累加到结果数组的相应位置上。

3. 核心算法实现

下面是高精度大数乘法的核心代码实现:

#include<bits/stdc++.h>
using namespace std;

int a[1000005], b[1000005], c[2000010];  // 存储大数的数组

int main() {  
    string s1, s2;  
    cin >> s1 >> s2; 

    // 获取两个数的长度
    int la = s1.length();  
    int lb = s2.length();
    
    // 将字符串转化为倒序的数组
    for (int i = 0; i < la; i++) {  
        a[la - i - 1] = s1[i] - '0';  // 将字符转为数字并倒序存储
    }  
    for (int i = 0; i < lb; i++) {  
        b[lb - i - 1] = s2[i] - '0';  // 同样处理第二个大数
    }  
    
    // 初始化结果数组 c 为 0
    memset(c, 0, sizeof(c));  
    
    // 核心大数乘法计算
    for (int i = 0; i < la; i++) {  
        for (int j = 0; j < lb; j++) {  
            c[i + j] += a[i] * b[j];  // 将 a[i] * b[j] 的结果累加到 c[i + j]
            c[i + j + 1] += c[i + j] / 10;  // 处理进位
            c[i + j] %= 10;  // 保留当前位的个位数
        }  
    }  
    
    // 处理高位的进位(去掉前导零)
    int lc = la + lb;  
    while (lc > 1 && c[lc - 1] == 0) {  
        lc--;  // 去掉多余的高位 0
    }  
    
    // 输出结果(倒序输出)
    for (int i = lc - 1; i >= 0; i--) {  
        cout << c[i];  
    }  
    cout << endl;  
      
    return 0;  
}

3.1 代码详解

  1. 输入处理
    首先将输入的大数存储在字符串 s1s2 中。然后我们将字符串中的每一位转换为对应的数字,并倒序存储在数组 a[]b[] 中。这是因为我们需要从最低位开始逐位相乘。
  2. 逐位相乘
    通过双重循环遍历数组 a[]b[] 的每一位,计算每一对数字的乘积,并将结果累加到 c[i + j] 中。这一步的关键是:a[i] * b[j] 的结果会影响最终乘积的第 i + j 位。
  3. 进位处理
    如果 c[i + j] 中的值大于等于 10,就需要进行进位处理。我们将进位值加到 c[i + j + 1] 中,并确保当前位只保留个位数(通过 c[i + j] %= 10)。
  4. 去掉前导零
    在完成所有乘法计算后,结果数组 c[] 可能会有一些多余的高位零。通过一个 while 循环,我们可以去掉这些前导零,确保输出的结果没有多余的零。
  5. 结果输出
    因为乘法结果是从低位到高位存储在 c[] 中的,因此我们需要从 c[] 的最高位开始逆序输出,得到正确的乘法结果。

4. 进位处理的详细解释

在乘法过程中,进位是一个非常重要的步骤。假设我们在手工计算时,乘积的结果超过 10,那么就需要将十位数进位。对于大数乘法来说,进位的处理过程如下:

  • 我们将 a[i] * b[j] 的结果加到 c[i + j] 中。
  • 如果 c[i + j] 的值大于等于 10,则需要将 c[i + j] / 10 的值加到 c[i + j + 1] 中(即进位到更高的一位)。
  • 然后用 c[i + j] %= 10 保留当前位的个位数,确保当前位只保留小于 10 的值。

这种逐位累加和进位处理的方式保证了我们最终得到的乘法结果是正确的。

5. 去掉前导零

在大数乘法的最后一步,我们需要去掉乘法结果中的前导零。假设乘法结果是 "000123",那么我们只需要输出 "123",即去掉前导的 0。这一步通过 while 循环来实现:

while (lc > 1 && c[lc - 1] == 0) {
    lc--;  // 去掉前导零
}

6. 复杂度分析

对于两个长度分别为 nm 的大数,逐位乘法的时间复杂度是 O(n * m),即双重循环遍历每一位数进行乘法。这是高精度乘法的标准算法,尽管其效率不如更复杂的快速傅里叶变换(FFT)乘法,但在处理一般情况下的大数乘法时,这种方法足够高效且容易实现。

总结

高精度乘法是解决大数乘法问题的常用方法。通过将大数存储为数组并逐位计算乘积,我们可以有效地模拟手工乘法的过程。关键点在于正确处理进位以及去掉前导零。本文提供的代码实现展示了如何使用这种方法进行高精度乘法运算。希望通过本文的讲解,你能更好地理解和掌握大数乘法的核心算法!

在日常的算法面试和刷题过程中,滑动窗口问题是非常常见的类型。今天我们来详细解答如何通过单调队列的方法找到滑动窗口中的最小值,并通过具体代码示例和步骤拆解,帮助大家更好地理解这一算法。

问题描述

给定一个数组和一个整数 k,我们需要找到该数组中每个大小为 k 的连续子数组中的最小值。

举例来说,给定数组 a = [2, 1, 3, 4, 5],窗口大小为 k=3,我们需要找到以下滑动窗口中的最小值:

  • [2, 1, 3] 的最小值为 1
  • [1, 3, 4] 的最小值为 1
  • [3, 4, 5] 的最小值为 3

输出结果应该是:1 1 3

思路

我们使用单调队列来解决这一问题。队列中存储的是数组中元素的下标,队列中的元素保持单调递减。这样队头元素总是滑动窗口的最小值。

主要步骤:

  1. 保持队列单调性:当有新的元素进入窗口时,我们需要移除队列中比新元素大的值,因为这些值在窗口中已经不可能成为最小值。
  2. 移除过期元素:当滑动窗口右移时,窗口中最左边的元素可能已经超出了窗口范围,我们需要从队列中移除它。
  3. 输出当前窗口的最小值:当窗口大小达到 k 时,输出队头元素即为当前窗口的最小值。

代码实现

int hh = 0, tt = -1;  // 初始化队列的头和尾指针
for (int i = 1; i <= n; i++) {
    // 判断队头是否在窗口范围内,不在则移除
    if (hh <= tt && q[hh] < i - k + 1) hh++;
    
    // 保持队列单调递减,移除比当前元素大的队尾元素
    while (hh <= tt && a[i] <= a[q[tt]]) tt--;
    
    // 当前元素入队
    q[++tt] = i;
    
    // 窗口达到大小 k 时,输出当前窗口的最小值
    if (i > k - 1) cout << a[q[hh]] << " ";
}
puts("");  // 输出完毕后换行

详细示例分析

我们以 a = [2, 1, 3, 4, 5]k=3 为例,通过每一步的分析,帮助大家更好地理解代码的执行过程。

第 1 步 (i=1):

  • 当前元素:a[1] = 2
  • 判断是否移除队头元素:队列为空,不执行移除操作。
  • 判断是否保持单调性:队列为空,不执行移除操作。
  • a[1] 的下标 1 入队,队列状态:q = [1]
  • 当前窗口还不足 k 个元素,不输出最小值。

第 2 步 (i=2):

  • 当前元素:a[2] = 1
  • 判断是否移除队头元素:队列头元素 q[hh] = 1 还在窗口范围内,不移除。
  • 保持单调性:当前元素 a[2] = 1 小于队尾元素 a[1] = 2,移除队尾元素。
  • a[2] 的下标 2 入队,队列状态:q = [2]
  • 当前窗口还不足 k 个元素,不输出最小值。

第 3 步 (i=3):

  • 当前元素:a[3] = 3
  • 判断是否移除队头元素:队列头元素 q[hh] = 2 还在窗口范围内,不移除。
  • 保持单调性:当前元素 a[3] = 3 大于队尾元素 a[2] = 1,不移除队尾元素。
  • a[3] 的下标 3 入队,队列状态:q = [2, 3]
  • 当前窗口已达到 k 个元素,输出当前窗口的最小值 a[q[hh]] = a[2] = 1
  • 输出:1

第 4 步 (i=4):

  • 当前元素:a[4] = 4
  • 判断是否移除队头元素:队列头元素 q[hh] = 2 超出窗口范围,移除队头元素。
  • 保持单调性:当前元素 a[4] = 4 大于队尾元素 a[3] = 3,不移除队尾元素。
  • a[4] 的下标 4 入队,队列状态:q = [3, 4]
  • 当前窗口已达到 k 个元素,输出当前窗口的最小值 a[q[hh]] = a[3] = 1
  • 输出:1

第 5 步 (i=5):

  • 当前元素:a[5] = 5
  • 判断是否移除队头元素:队列头元素 q[hh] = 3 还在窗口范围内,不移除。
  • 保持单调性:当前元素 a[5] = 5 大于队尾元素 a[4] = 4,不移除队尾元素。
  • a[5] 的下标 5 入队,队列状态:q = [3, 4, 5]
  • 当前窗口已达到 k 个元素,输出当前窗口的最小值 a[q[hh]] = a[3] = 3
  • 输出:3

最终输出:

1 1 3

关键部分解释

  1. 移除队头元素

    if (hh <= tt && q[hh] < i - k + 1) hh++;

    这个条件判断队列头元素是否超出了当前窗口范围,如果队头下标不在窗口内,就将其移除。

  2. 保持单调队列

    while (hh <= tt && a[i] <= a[q[tt]]) tt--;

    我们需要保证队列中的元素保持单调递减。每当有新元素加入队列时,我们移除所有比它大的元素,因为这些较大的元素在当前窗口中不可能再成为最小值。

  3. 输出最小值

    if (i > k - 1) cout << a[q[hh]] << " ";

    当遍历到第 k 个元素及以后时,窗口的大小达到 k,此时输出队列头的元素作为当前窗口的最小值。

总结

通过使用单调队列,我们能够高效地解决滑动窗口最小值问题。时间复杂度为 O(n),因为每个元素最多入队和出队各一次。单调队列是一种非常有用的技巧,特别是在涉及动态范围查询的问题时。

之前买的gv号,可能是因为我一直发一些无意义的短信例如“1”或图片来保号,结果号被封了。
然后我登我自己的google邮箱,发现好像可以领账号了,就是这么神奇,突然可以用了。
我怀疑,现在如果我用指纹浏览器再去注册一个gv号应该也是可以的,但是不是很想搞。
有一个在自己邮箱上就很满足了。现在就是主要有两个虚拟号,一个是gv另外一个就是talkatone。
我发现如果只是来玩的话,其实talkatone的可玩性或许会高一点,因为他的成本比较低,只要一个静态ip就行。