• 字符串匹配——KMP算法



    关于KMP算法的分析,我觉得这两篇博客写的不错:

    http://www.ruanyifeng.com/blog/2013/05/Knuth–Morris–Pratt_algorithm.html

    http://blog.csdn.net/v_JULY_v/article/details/6545192

    下面的笔记也是参考了这两篇博客的。


    KMP算法是最有名的字符串匹配算法了。它是BF算法的改进版,至于是如何改进的,先引用上述第二篇博客里的一段话:


            “在继续分析之前,咱们来思考这样一个问题:为什么快排或者堆排序比直接的选择排序快?直接的选择排序,每次都是重复地比较数值的大小,每扫描一次,只得出一个最大(小值),再没有其它的成果。而快排,每扫一次,将数据分成了两部分,右边的数据都大于左边的数据,所以在下一次比较的时候,这两部分元素之间就不用比较了。再看堆排序,建堆的过程也是O(n)的比较,但比较的结果得到了最大(小)堆这种三角关系,之后的比较就不用再每一个都需要比较了。

            由上述思考,咱们总结出了一点优化的归律:采用一种简单的数据结构或者方式,将每次重复性的工作得到的信息记录得尽量多,方便下一次做同样的工作,这样将带来一定的优化。”


    总结上面这段话的核心思想,就是把循环中要重复做的工作提取到循环外完成,从而提高效率。


    下面用一个例子演示KMP匹配的过程。其中涉及的三个数据如下:

            source:源串,即要匹配的母船

            pattern:模式串,即子串

            next数组:其每个元素对应pattern的每个字符,表示当该字符pattern[j]不匹配source[i]时,应该从pattern的哪个下标开始重新匹配当前的source[i],具体求法后面介绍


    本例中source为ABCABCABDE,pattern为ABCABD,第一次匹配,前5个字符均匹配成功,匹配第6个字符时如下:



    此时发现source[5]和pattern[5]不匹配,BF算法的做法是从source[1]开始从新匹配pattern,即像下面这样:



    而KMP算法则不会再去重新比较source[1...4]了,它会利用next的信息调整pattern。因为next[5]=2,所以下一次匹配将当前的source[5]和pattern[2]比较,即像下面这样:



    这时发现source[5]和pattern[2]匹配,继续往下比较,直至pattern中所以元素都比较完了,如下:



    此时已经在母串中找到了子串,i=9,m=6,所以返回的下标为i-m=3。


    这样整个匹配过程就完了,感觉不过瘾吗,前面两篇推荐的博客里有更长的匹配串分析。


    把上面的过程翻译成代码,也就是KMP算法的实现,如下:

    int KMP(char *source, char *pattern)
    {
    	int i, j, m, n;
    	int *next;
    
    	i = 0;
    	j = 0;
    	m = strlen(pattern);
    	n = strlen(source);
    	next = (int *)malloc(m * sizeof(int));
    
    	Next(pattern, next);<span style="white-space:pre">	</span>// 这是求next数组的函数,后面解释
    
    	while (i < n && j < m)
    	{
    		if (j == -1 || source[i] == pattern[j])
    		{
    			++i;
    			++j;
    		}
    		else
    		{
    			j = next[j];
    		}
    	}
    
    	free(next);
    
    	if (j == m)
    	{
    		return i - m;
    	}
    	else
    	{
    		return -1;
    	}
    }

    下面来看next数组是如何求得的。


    如前所述,next数组里保存的就是pattern[j]与母串中的字符不匹配时,该用哪个下标继续和这个字符匹配。若next[j]=k,则有:pattern[0...k-1] = pattern[j-k...j-1],而且这个k是最大的,即不会有pattern[0...k] =pattern[j-k-1...j-1]。


    反过来想,如果已经知道了pattern[0...k-1] = pattern[j-k...j-1],next[j]是多少呢?要分两种情况考虑:

            1. pattern[k] != pattern[j],则next[j] = k

            2. pattern[k] = pattern[j],则next[j] = next[k]

    第二种情况是因为,若pattern[k] = pattern[j]时,也使next[j]=k;则在pattern[j]于母串不匹配的情况下,再拿pattern[next[j]]即pattern[k]去比较的话,肯定也是不匹配的。这是隐藏的重复工作。使next[j] = next[k]就能避免这种重复工作。


    那么怎么又能保证pattern[j]不会等于pattern[next[k]]呢?不急,一步一步想:最开始有next[0]=-1,如果pattern[1]=pattern[0],那么由规则2,next[1]=next[0]=-1;再如果pattern[2]=pattern[1],那么next[2]=next[1]=-1。看到了吗,三个一样的字符,如果是next依次为前一个元素的情况,最终都会是最前面那个next值,这就保证了最大的减少重复工作。


    好吧,上面的解释很挫,意会吧。其实就跟离散树一样,同一个集合的元素都有相同的根。


    有了上面的规则后,求next数组就比较方便了。用动态规划的策略很好实现:

    void Next(char *pattern, int *next)
    {
    	int i, j, n;
    
    	i = 0;
    	j = -1;
    	next[0] = -1;
    	n = strlen(pattern);
    
    	while (i < n - 1)
    	{
    		if (j == -1 || pattern[i] == pattern[j])
    		{
    			++i;
    			++j;
    
    			if (pattern[i] != pattern[j])
    			{
    				next[i] = j;
    			}
    			else
    			{
    				next[i] = next[j];
    			}
    		}
    		else
    		{
    			j = next[j];
    		}
    	}
    }

    是不是感觉和KMP的框架很像,其实就是一回事,都是子串匹配,都利用了next数组。

    不同之处在于:KMP是source匹配pattern,Next是一直从pattern的头部开始匹配后面所有的序列;在Next里面,next数组还没有完全生成,是利用前面生成的next加上匹配结果生成下一个next,这就是动规的策略。


  • 相关阅读:
    【USACO】clocks 遇到各种问题 最后还是参考别人的思路
    【USACO】calfflac
    【USACO】namenum
    【USACO】beads
    最大流问题
    模运算性质 摘自百度百科
    学历是铜牌,能力是银牌,人脉是金牌,思维是王牌
    U盘版Windows 10已经在亚马逊Amazon開始接受预订啦
    hadoop实验:求气象数据的最低温度
    Appium Android Bootstrap源代码分析之启动执行
  • 原文地址:https://www.cnblogs.com/ltxdzh/p/3960139.html
Copyright © 2020-2023  润新知