文档章节

Substring Search

o
 osc_pn11u1x9
发布于 2018/08/07 17:12
字数 2535
阅读 0
收藏 0

钉钉、微博极速扩容黑科技,点击观看阿里云弹性计算年度发布会!>>>

查找子字符串

Introduction

在长度为 N 的文本里寻找长度为 M 的模式(子串),典型情况是 N >> M。

pattern-text

这个应用就很广泛啦,在文本中寻找特定的模式(子串)是很常见的需求。

Brute Force

我们先来了解一下暴力查找。

brute-force

就暴力地两个循环,查找文本的每个位置,最坏情况下需要近似 $MN$ 次字符比较。

brute-force-worst-case

稍微贴下代码:

public static int search(String pat, String txt) {
    int M = pat.length();
    int N = txt.length();
    for (int i = 0; i <= N - M; i++) {
        int j;
        for (j = 0; j < M; j++)
            if (txt.charAt(i + j) != pat.charAt(j))
                break;
        if (j == M) return i;    // index in txt where pattern starts
        return N;    // not found
    }
}

暴力算法有可能会跑的很慢,而且还存在一个回退(backup)问题:

brute-force-backup

这是暴力算法的另一个实现代码(显示回退):

public static int search(String pat, String txt) {
    int i, N = txt.length();
    int j, M = pat.length();
    for (i = 0, j = 0; i < N && j < M; i++) {
        if (txt.charAt(i) == pat.charAt(j)) j++;
        else {
            i -= j;    // explicit backup
            j = 0;
        }
        if (j == M) return i - M;
        else return N;    // not found
    }
}

所以暴力算法并不是总能满足我们的需求,我们希望有线性时间级别的性能保证,希望避免在文本流中回退。

Knuth-Morris-Pratt

KMP 算法一下子解决了上面两个问题,既不用回退,最多也只要访问 N 次字符,于是我们先来了解下 DFA

Deterministic Finite State Automaton

确定型有穷(状态)自动机(DFA),是一个抽象的字符串查找机器。

  • 状态数目是有穷的(包括初始状态和终结状态)。

  • 每个状态对每个字符有且仅有一个转移。

  • 转移到终结状态则接受这个字符串,即含有我们寻找的子串(模式)。

比如说,现在我们在一个由字母 A, B 和 C 组成的文本中寻找子串:ABABAC,DFA 长这样:

dfa-graph

具体实现时用二维数组表示就好:

           j    0    1    2    3    4    5
                --------------------------
pat.charAt(j)   A    B    A    B    A    C    if in state j reading char c:
           |A   1    1    3    1    5    1        if j is 6 halt and accept
   dfa[][j]|B   0    2    0    4    0    4        else move to state dfa[c][j]
           |C   0    0    0    0    0    6

其中 dfa[i][j] 表示状态 j 遇到字符 i 会转移到下一个状态,并不包括终结状态。

现在查找子串就很简单啦,一开始在初始状态,文本流读到哪个字符就往哪条路走,要是走到了终结状态,也就表示找到了子串。像我们这样构造的 DFA,走到状态几,就说明已经匹配了多少个字符其实,所以走到终结状态就表示全部匹配。例子,状态三:

dfa-state

KMP Substring Search: Java Implementation

public int search(String txt) {
    int i, j, N = txt.length();
    for (i = 0, j = 0; i < N && j < M; i++)
        j = dfa[txt.chaAt(i)][j];    // no backup
    if (j == M) return i - M;
    else return N;    // not found
}

在二维数组 dfa 的指导下,查找子串的代码很简单,即没有回退,最多也只要 N 次字符访问。于是乎,关键就在于如何从要查找的子串构造相应的 dfa[][] 啦。

Construct DFA

  1. Match Transition

    匹配时的转移很好办,直接到下一个状态即可。

    match-transition

  2. Mismatch Transition

    关键在不匹配时该如何转移。

    假设在状态 j 时读到的下一个字符 c 不等于要找的子串的第 j + 1 个字符(pat.charAt(j),从 0 标号),那么这个时候,我们从文本流中最近读出的 j - 1 个字符即为 pat[1..j - 1] + c,就是暴力算法要重新扫描的部分。

    当前首字母到状态 j 出现了不匹配,按暴力算法该丢弃它从下一个字母再开始,即 pat[1],再一路重新扫描到 c。所以,现在状态 j 遇到 c 该怎么转移,实际上和字符串 pat[1.. j - 1] + c 在 DFA 中所到状态碰到 c 的转移目标一样才对。于是我们这么计算 dfa[c][j]:在 DFA 上模拟 pat[1.. j - 1],然后直接取字符 c 的转移

    举个例子来看,如何计算状态 5 碰到字符 A 和 B 的转移:

    mismatch-transition

    这样,乍一看需要 j 步来模拟暴力算法中回退部分字符输入到 DFA,从而找到不匹配时的重启状态(像上图的状态 3)。但其实,我们可以花很小的成本来维护重启状态 X,不匹配时就能一下知道该转移到哪。其实也就是从 pat[1] 开始匹配而已,具体可以看下面代码。

Construcing DFA For KMP: Java Implementation

public KMP(String pat) {
    this.pat = pat;
    M = pat.length();
    dfa = new int[R][M];
    dfa[pat.charAt(0)][0] = 1;            // 初始状态只要这一个转移,其它还是自己(0)
    // 构造 dfa[][1..M - 1] 没有终结状态的转移
    for (int X = 0, j = 1; j < M; j++) {
        for (int c = 0; c < R; c++)
            dfa[c][j] = dfa[c][X];        // copy mismatch cases
        // 匹配时,状态和重启状态没关系,以当前状态为主,直接下一状态
        dfa[pat.charAt(j)][j] = j + 1;    // set match case
        // 从 pat[1] 开始匹配
        X = dfa[pat.charAt(j)][X];        // update restart state
    }
}

Boyer-Moore

Boyer-Moore 算法采用启发式(heuritic)的方法处理不匹配的字符,从右向左扫描模式字符串(长度为 M)并将它和文本匹配,不匹配的时候最多可以跳过 M 个文本中的字符,在实际应用中近似能达到 $N/M$ 级别。例子:

boyer-moore

第一次文本中的 N 和模式中的 E 不匹配,因为模式串中含有 N,所以将模式中最右边的 N 和其对齐,模式一下就向右移动了 5 位。第二次不匹配时,因为模式串中没有 S,更是直接将模式串移动了 6 位(即 M 位)。最终找到匹配的位置总共也只比较了四次,还有另外六次用来验证匹配。

因为实际中模式串经常只包含字母表中一些字符,在文本中查找的时候经常碰到模式串中没有的字符,所以几乎全部都是这种跳过 M 位的,故近似有 $N/M$ 级别。

于是关键就在于:移动几位,具体可以分为以下三种情况:

  1. 不匹配字符不在模式串中。

    case1

    这是最简单的情况,直接移动 M 位。

  2. 不匹配字符在模式串中,情形一。

    case2a

    将模式串中最右边的该字符和文本中的对齐。

  3. 不匹配字符在模式串中,情形二。

    case2b

    这时要是按上面和最右边的对齐,模式串会往左边移动发生回退,移动位数是负数。所以这时没办法跳过很多字符,只能老实地右移一位。

具体的实现时,对模式串进行下预处理,维护一个数组 right[R] 来指导跳过几位就好。

rigth = new int[R];
for (int c = 0; c < R; c++)
    right[c] = -1;    // 模式串中没有该字符则记为 -1
for (int j = 0; j < M; j++)
    right[pat.charAt(j)] = j;

Boyer-Moore: Java Implementation

public int search(String txt) {
    int N = txt.length();
    int M = pat.length();
    int skip;
    for (int i = 0; i <= N - M; i += skip) {
        skip = 0;
        for (int j = M - 1; j >= 0; j--) {
            if (pat.charAt(j) != txt.charAt(i + j)) {
                // in case other term is nonpositive
                skip = Math.max(1, j - right[txt.charAt(i + j)]);
            }
        }
        if (skip == 0) return i;    // match
    }
    return N;
}

最坏的情况下,Boyer-Moore 算法会退化到近似 $MN$ 的级别,就是都是最后一种情形,每次只能移动一位。

worst-case

完整的 Boyer-Moore 算法和 KMP 算法类似有个记录不匹配时的重启位置的数组,能给最坏情况提供线性级别的性能保证,跳过的位数也可能不止 M 位。不过对一般的应用程序,启发式的处理不匹配字符已经足够了,所以不展开,据说就是从模式串右边开始构造 DFA。

Rabin-Karp

Rabin-Karp 指纹字符串查找算法基于模数(modular)散列,直接上图:

rabin-krap

我们用的散列函数如下:

$x_{i} = c_{i}R^{M - 1} + c_{i + 1}R^{M - 2} + ... + c_{i + M - 1}R^{0}$ (mod Q)

$c_{i}$ 表示第 i 位的字符,Q 就是一个很大的素数(也要注意不要溢出)。然后再用 Horner 方法(霍尔法则计算 n 次多项式)在线性时间内计算出来:

// Compute hash for M-digit key
private long hash(String key, int M) {
    long h = 0;
    for (int j = 0; j < M; j++)
        h = (R * h + key.charAt(j)) % Q;
    return h;
}

上面的方法模式串和文本都能用,但每次计算文本的子串的散列需要访问 M 个字符,那和暴力算法不都是近似 $MN$ 级别。Rabin-Karp 算法的关键就在于它能够在线性时间内算出文本子串的散列值,只要稍微预处理一下。

考虑下如何在已知 $x_{i}$ 的情况下高效地算出 $x_{i + 1}$,写出式子:

$x_{i} = c_{i}R^{M - 1} + c_{i + 1}R^{M - 2} + ... + c_{i + M - 1}R^{0}$

$x_{i + 1} = c_{i + 1}R^{M - 1} + c_{i + 2}R^{M - 2} + ... + c_{i + M}R^{0}$

不难推出:

$x_{i + 1} = (x_{i} - t_{i}R^{M - 1}) R + t_{i + M}$

可以先把 $R^{M - 1}$ 算好,例子:

quick-txt-hash

Rabin-Krap: Java Implementation

public class RabinKrap {
    private long patHash;    // pattern hash value
    private int M;           // pattern length
    private long Q;          // modulus
    private int R;           // radix
    private long RM;         // R^(M-1) % Q

    public RabinKrap(String pat) {
        R = 256;
        M = pat.length();
        patHash = hash(pat, M);
        // a large prime
        // but avoid overflow
        Q = longRandomPrime();

        RM = 1;
        for (int i = 1; i <= M -1; i++)
            RM = (R * RM) % Q;
    }

    public int search(String txt) {
        int N = txt.length();
        int txtHash = hash(txt, M);
        if (patHash == txtHash) return 0;
        for (int i = M; i < N; i++) {
            txtHash = (txtHash + Q - RM * txt.charAt(i - M) % Q) % Q;
            txtHash = (txtHash * R + txt.charAt(i)) % Q;
            if (patHash == txtHash) return i - M + 1;    // Monte Carlo version
        }
        return N;    // not found
    }
}

蒙特卡洛版本在散列匹配时直接返回,因为散列表的规模 Q 很大,冲突概率很小,这样可以保证运行时间。另有拉斯维加斯(Las Vegas)版本散列值匹配后还会回退比较字符,以此来保证正确性,但可能会很慢。

Rabin-Karp 算法的优点是容易拓展,像是拓展到查找多模式,查找二维模式等,缺点是算术运算会比其它算法的字符比较慢等。

o
粉丝 0
博文 500
码字总数 0
作品 0
私信 提问
加载中
请先登录后再评论。

暂无文章

VB语言基础重要知识点12

我们课程,我们做一些针对于考试的简要讲解。 一、有关考试的几个问题 首先,提问:考试最重要的是什么? 答案其实很简单:得分!!!!! 想要得分,就要做到基本的保存。 保存哪些文件呢?...

刘金玉编程
2019/10/30
5
0
全网最全JAVA、Python电子书!限时领取,过时不候!

给大家整理了最全的入门+进阶书籍!!! 免费领取,无套路! 加微信发送“电子书” 秒通过,秒发资源! 本文分享自微信公众号 - Python进击者(JAVAandPythonJun)。 如有侵权,请联系 supp...

kuls
01/16
18
0
原创356--免费还是付费

最近得有一个星期,被一个录屏软件(record it)烦到了,本来免费版可以无限制录制,只能720p,GIF不支持,高清不支持,没有剪辑功能。 之前调研了好几种,用起来还是这个方便,就一直用了。...

八音弦
04/24
14
0
数字IC技术讨论群,设计和验证、前端和后端,总有你感兴趣的话题。快满了,需要的抓紧加入。

本文分享自微信公众号 - 白山头讲IC(gray_mount)。 如有侵权,请联系 support@oschina.cn 删除。 本文参与“OSC源创计划”,欢迎正在阅读的你也加入,一起分享。...

白山头
04/29
5
0
how to install mongodb in centos7

[root@xtwj88 ~]# cat /etc/yum.repos.d/mongodb-org-4.2.repo [mongodb-org-4.2]name=MongoDB Repositorybaseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/4.2/x86......

qwfys
59分钟前
13
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部