精华内容
下载资源
问答
  • KMP求next数组中的图片

    2020-11-08 18:28:26
    KMP算法求next数组这篇博客中有几张图片,但是博客中图片是竖着的,不方便查看,但我又不知道如何旋转图片,提供博客中的图片,方便下载到自己的电脑上进行查看
  • KMP求next数组详解

    2015-01-05 19:49:55
    我们在一个母字符串中查找一个子字符串有很多方法。KMP是一种最常见的改进算法,它可以在...在KMP算法中有个数组,叫做前缀数组,也有的叫next数组,每一个子串有一个固定的next数组,它记录着字符串匹配过程中失配情况

    我们在一个母字符串中查找一个子字符串有很多方法。KMP是一种最常见的改进算法,它可以在匹配过程中失配的情况下,有效地多往后面跳几个字符,加快匹配速度。

    当然我们可以看到这个算法针对的是子串有对称属性,如果有对称属性,那么就需要向前查找是否有可以再次匹配的内容。

     

    在KMP算法中有个数组,叫做前缀数组,也有的叫next数组,每一个子串有一个固定的next数组,它记录着字符串匹配过程中失配情况下可以向前多跳几个字符,当然它描述的也是子串的对称程度,程度越高,值越大,当然之前可能出现再匹配的机会就更大。

    这个next数组的求法是KMP算法的关键,但不是很好理解,我在这里用通俗的话解释一下,看到别的地方到处是数学公式推导,看得都蛋疼,这个篇文章仅贡献给不喜欢看数学公式又想理解KMP算法的同学。

     

    1、用一个例子来解释,下面是一个子串的next数组的值,可以看到这个子串的对称程度很高,所以next值都比较大。

    位置i

    0

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    前缀next[i]

    0

    0

    0

    0

    1

    2

    3

    1

    2

    3

    4

    5

    6

    7

    4

    0

    子串

    a

    g

    c

    t

    a

    g

    c

    a

    g

    c

    t

    a

    g

    c

    t

    g

    申明一下:下面说的对称不是中心对称,而是中心字符块对称,比如不是abccba,而是abcabc这种对称。

    (1)逐个查找对称串。

    这个很简单,我们只要循环遍历这个子串,分别看前1个字符,前2个字符,3个... i个 最后到15个。

    第1个a无对称,所以对称程度0

    前两个ag无对称,所以也是0

    依次类推前面0-4都一样是0

    前5个agcta,可以看到这个串有一个a相等,所以对称程度为1前6个agctag,看得到ag和ag对成,对称程度为2

    这里要注意了,想是这样想,编程怎么实现呢?

    只要按照下面的规则:

    a、当前面字符的前一个字符的对称程度为0的时候,只要将当前字符与子串第一个字符进行比较。这个很好理解啊,前面都是0,说明都不对称了,如果多加了一个字符,要对称的话最多是当前的和第一个对称。比如agcta这个里面t的是0,那么后面的a的对称程度只需要看它是不是等于第一个字符a了。

     

    b、按照这个推理,我们就可以总结一个规律,不仅前面是0呀,如果前面一个字符的next值是1,那么我们就把当前字符与子串第二个字符进行比较,因为前面的是1,说明前面的字符已经和第一个相等了,如果这个又与第二个相等了,说明对称程度就是2了。有两个字符对称了。比如上面agctag,倒数第二个a的next是1,说明它和第一个a对称了,接着我们就把最后一个g与第二个g比较,又相等,自然对称成都就累加了,就是2了。

     

    c、按照上面的推理,如果一直相等,就一直累加,可以一直推啊,推到这里应该一点难度都没有吧,如果你觉得有难度说明我写的太失败了。

    当然不可能会那么顺利让我们一直对称下去,如果遇到下一个不相等了,那么说明不能继承前面的对称性了,这种情况只能说明没有那么多对称了,但是不能说明一点对称性都没有,所以遇到这种情况就要重新来考虑,这个也是难点所在。

     

    (2)回头来找对称性

    这里已经不能继承前面了,但是还是找对称成都嘛,最愚蠢的做法大不了写一个子函数,查找这个字符串的最大对称程度,怎么写方法很多吧,比如查找出所有的当前字符串,然后向前走,看是否一直相等,最后走到子串开头,当然这个是最蠢的,我们一般看到的KMP都是优化过的,因为这个串是有规律的。

    在这里依然用上面表中一段来举个例子:   

    位置i=0到14如下,我加的括号只是用来说明问题:

    (a g c t a g c )( a g c t a g c) t

    我们可以看到这段,最后这个t之前的对称程度分别是:1,2,3,4,5,6,7,倒数第二个c往前看有7个字符对称,所以对称为7。但是到最后这个t就没有继承前面的对称程度next值,所以这个t的对称性就要重新来求。

    这里首要要申明几个事实

    1、t 如果要存在对称性,那么对称程度肯定比前面这个c 的对称程度小,所以要找个更小的对称,这个不用解释了吧,如果大那么t就继承前面的对称性了。

    2、要找更小的对称,必然在对称内部还存在子对称,而且这个t必须紧接着在子对称之后。

    如下图说明。

     

    从上面的理论我们就能得到下面的前缀next数组的求解算法。

    void SetPrefix(const char *Pattern, int prefix[])

    {

         int len=CharLen(Pattern);//模式字符串长度。

         prefix[0]=0;

         for(int i=1; i<len; i++)

         {

             int k=prefix[i-1];

             //不断递归判断是否存在子对称,k=0说明不再有子对称,Pattern[i] != Pattern[k]说明虽然对称,但是对称后面的值和当前的字符值不相等,所以继续递推

             while( Pattern[i] != Pattern[k]  &&  k!=0 )               

                 k=prefix[k-1];     //继续递归

             if( Pattern[i] == Pattern[k])//找到了这个子对称,或者是直接继承了前面的对称性,这两种都在前面的基础上++

                  prefix[i]=k+1;

             else

                  prefix[i]=0;       //如果遍历了所有子对称都无效,说明这个新字符不具有对称性,清0

         }

    }

    通过这个说明,估计能够理解KMP的next求法原理了,剩下的就很简单了。我自己也有点晕了,实在不喜欢那些数学公式,所以用形象逻辑思维方法总结了一下。

    展开全文
  • * 目的:文字描述数组w中 包含关键字数组q中所有元素的 最短子数组(w中包含q元素的子数组可以与q中的顺序不同,包含即可) * * 代码问题:不能处理关键中有相同单词的情况。例如:wo wo ni

    (1)以字符p为例

    (2)KMP算法代码实现

    
    import java.util.Scanner;
    
    public class Main {
    	/*  
    	 * 思路:
    	 * len、begin、end分别表示当前包含所有关键字的子数组最短长度、起始下标
    	 * 
    	 * 
    	 * 目的:求文字描述数组w中 包含关键字数组q中所有元素的 最短子数组(w中包含q元素的子数组可以与q中的顺序不同,包含即可)
    	 * 
    	 * 代码问题:不能处理关键中有相同单词的情况。例如:wo wo ni
    	 * */
    	
    	public static void main(String[] args){
    		//KMP算法
    		//1.设置主串和子串
    		char[] s1 = "acbababcbabababb".toCharArray();//主串
    		char[] s2 = "bab".toCharArray();//子串
    		
    		//2.获取next数组
    		int[] next = getnext(s2);
    		
    		//3.比较
    		int j=0;
    		for(int i=0;i<s1.length && j<s2.length;) {
    			if(j==-1 || s2[j]==s1[i]) {
    				j++;
    				i++;
    			}else {
    				j = next[j];
    			}
    			//4.判断是否匹配成功
    			if(j==s2.length) {
    				System.out.println("匹配成功,匹配位置为:"+(i-s2.length));
    				break;
    			}
    		}//for
    		
    	}
    	//构造next数组
    	private static int[] getnext(char[] str) {
    		int[] next = new int[str.length];//next数组
    		//1.初始化前两个值
    		next[0]=-1;
    		next[1]=0;
    		int k = next[1];
    		for(int j=1;j<str.length;j++) {
    			if(k<0 || str[j]==str[k]) {//相等
    				k++;
    				j++;
    			}else {//不等
    				k = next[k];
    			}
    		}
    		
    		return next;
    	}
    }
    	
    
    

     

    展开全文
  • kmp求next数组值的方法

    千次阅读 2010-10-03 09:28:00
    例如: 模式串abaabcac next值01122312 nextval值 next数组的求解方法是:第一位的next值为0,第二位的next值为1,后面求解每一位的next值时,根据前一位进行比较。首先将前一位与其next值对应的内容进行比较,...

    。。。。。。。。。网上转载的。。。。。。。。。。

    首先看看next数组值的求解方法。
          
    例如: 模式串abaabcac     next01122312     nextval       next数组的求解方法是:第一位的next值为0,第二位的next值为1,后面求解每一位的next值时,根据前一位进行比较。首先将前一位与其next值对应的内容进行比较,如果相等,则该位的next值就是前一位的next值加上1;如果不等,向前继续寻找next值对应的内容来与前一位进行比较,直到找到某个位上内容的next值对应的内容与前一位相等为止,则这个位对应的值加上1即为需求的next值;如果找到第一位都没有找到与前一位相等的内容,那么需求的位上的next值即为1
          
    看起来很令人费解,利用上面的例子具体运算一遍。
           1.
    前两位必定为01
           2.
    计算第三位的时候,看第二位bnext值,为1,则把b1对应的a进行比较,不同,则第三位anext的值为1,因为一直比到最前一位,都没有发生比较相同的现象。
           3.
    计算第四位的时候,看第三位anext值,为1,则把a1对应的a进行比较,相同,则第四位anext的值为第三位anext值加上1。为2。因为是在第三位实现了其next值对应的值与第三位的值相同。
           4.
    计算第五位的时候,看第四位anext值,为2,则把a2对应的b进行比较,不同,则再将b对应的next1对应的a与第四位的a进行比较,相同,则第五位的next值为第二位bnext值加上1,为2。因为是在第二位实现了其next值对应的值与第四位的值相同。
           5.
    计算第六位的时候,看第五位bnext值,为2,则把b2对应的b进行比较,相同,则第六位cnext值为第五位bnext值加上1,为3,因为是在第五位实现了其next值对应的值与第五位相同。
           6.
    计算第七位的时候,看第六位cnext值,为3,则把c3对应的a进行比较,不同,则再把第3anext1对应的a与第六位c比较,仍然不同,则第七位的next值为1
           7.
    计算第八位的时候,看第七位anext值,为1,则把a1对应的a进行比较,相同,则第八位cnext值为第七位anext值加上1,为2,因为是在第七位和实现了其next值对应的值与第七位相同。
          
    在计算nextval之前要先弄明白,nextval是为了弥补next函数在某些情况下的缺陷而产生的,例如主串为“aaabaaaab”、模式串为“aaaab”那么,比较的时候就会发生一些浪费的情况:比较到主串以及模式串的第四位时,发现其值并不相等,据我们观察,我们可以直接从主串的第五位开始与模式串进行比较,而事实上,却进行了几次多余的比较。使用nextval可以去除那些不必要的比较次数。
          
    nextval数组值有两种方法,一种是不依赖next数组值直接用观察法求得,一种方法是根据next数组值进行推理,两种方法均可使用,视更喜欢哪种方法而定。
          
    我们使用例子“aaaab”来考查第一种方法。
           1.
    试想,在进行模式匹配的过程中,将模式串“aaaab”与主串进行匹配的时候,如果第一位就没有吻合,即第一位就不是a,那么不用比较了,赶快挪到主串的下一位继续与模式串的第一位进行比较吧,这时,模式串并没有发生偏移,那么,模式串第一位anextval值为0
           2.
    如果在匹配过程中,到第二位才发生不匹配现象,那么主串的第一位必定是a,而第二位必定不为a,既然知道第二位一定不为a,那么主串的第一、二两位就没有再进行比较的必要,直接跳到第三位来与模式串的第一位进行比较吧,同样,模式串也没有发生偏移,第二位的nextval值仍然为0
           3.
    第三位、第四位类似2的过程,均为0
           4.
    如果在匹配过程中,直到第五位才发生不匹配现象,那么主串的第一位到第四位必定为a,并且第五位必定不为b,可是第五位仍然有可能等于a。如果万一第五位为a,那么既然前面四位均为a,所以,只要第六位为b,第一个字符串就匹配成功了。所以,现在的情况下,就是看第五位究竟是不是a了。所以发生了下面的比较: 123456aaaa**aaaabaaaab
          
    前面的三个a都不需要进行比较,只要确定主串中不等于b的那个位是否为a,即可以进行如下的比较:如果为a,则继续比较主串后面一位是否为b;如果不为a,则此次比较结束,继续将模式串的第一位去与主串的下一位进行比较。由此看来,在模式串的第五位上,进行的比较偏移了4位(不进行偏移,直接比较下一位为0),故第五位bnextval值为4
          
    我们可以利用第一个例子“abaabcac”对这种方法进行验证。
           a
    nextval值为0,因为如果主串的第一位不是a,那么没有再比较下去的必要,直接比较主串的第二位是否为a。如果比较到主串的第二位才发生错误,则主串第一位肯定为a,第二位肯定不为b,此时不能直接跳到第三位进行比较,因为第二位还可能是a,所以对主串的第二位再进行一次比较,偏移了1位,故模式串第二位的nextval值为1。以此类推,nextval值分别为:01021302。其中第六位的nextval之所以为3,是因为,如果主串比较到第六位才发生不匹配现象,那么主串的前五位必定为“abaab”且第六位必定不是“c”,但第六位如果为“a”的话,那么我们就可以从模式串的第四位继续比较下去。所以,这次比较为: 1234 5678910 11 12abaab*******abaabcac
          
    而不是: 1234 5678910 11 12abaab*******abaabca
          
    因为前两位ab已经确定了,所以不需要再进行比较了。所以模式串第六位的nextval值为这次比较的偏移量3
          
    再来看求nextval数组值的第二种方法。
    模式串abaabcac next01122312nextval01021302
           1.
    第一位的nextval值必定为0,第二位如果于第一位相同则为0,如果不同则为1
           2.
    第三位的next值为1,那么将第三位和第一位进行比较,均为a,相同,则,第三位的nextval值为0
           3.
    第四位的next值为2,那么将第四位和第二位进行比较,不同,则第四位的nextval值为其next值,为2
           4.
    第五位的next值为2,那么将第五位和第二位进行比较,相同,第二位的next值为1,则继续将第二位与第一位进行比较,不同,则第五位的nextval值为第二位的next值,为1
           5.
    第六位的next值为3,那么将第六位和第三位进行比较,不同,则第六位的nextval值为其next值,为3
           6.
    第七位的next值为1,那么将第七位和第一位进行比较,相同,则第七位的nextval值为0
           7.
    第八位的next值为2,那么将第八位和第二位进行比较,不同,则第八位的nextval值为其next值,为2
          
    “aaaab”内进行验证。 模式串aaaabnext01234nextval00004

    展开全文
  • KMPnext数组求法详解

    万次阅读 多人点赞 2018-07-31 20:20:05
    kmp算法的精髓就在于next数组,从而达到跳跃式匹配的高效模式。 而next数组的值是代表着字符串的前缀与后缀相同的最大长度,(不能包括自身)。 "前缀"指除了最后一个字符以外,一个字符串的全部头部组合;...

    部分参考了  BLOG

    kmp算法的精髓就在于next数组,从而达到跳跃式匹配的高效模式。

    而next数组的值是代表着字符串的前缀与后缀相同的最大长度,(不能包括自身)。

    "前缀"指除了最后一个字符以外,一个字符串的全部头部组合;

    "后缀"指除了第一个字符以外,一个字符串的全部尾部组合。

    这里举个例子:

     

     

    这样我们就求出来了next数组

    模式串t

    A

    B

    A

    B

    A

    A

    下标

    0

    1

    2

    3

    4

    5

    next

    0

    0

    1

    2

    3

    1

    当前后缀特别长的时候(假设该串大小为1000),我们当然不可能挨个去比较前后缀,next数组怎样用代码去求呢?

    仍然是上面那个例子

    A B A B A A

    模式串t

    A

    B

    A

    B

    A

    A

    下标

    0

    1

    2

    3

    4

    5

    next

    此时next数组的值,全为未知,

    1.初始化,next[0]为0;

    因为next[0]代表t[0]~t[0]即"X","X"的前缀和后缀都为空集,共有元素的长度为0.

    所以无论X的值为任意值,next[0]=0;

    模式串t

    A

    B

    A

    B

    A

    A

    下标

    0

    1

    2

    3

    4

    5

    next

    0

    2.求解next[1],

    • t[0] != t[1] next[1]为0; 假设此时为XY ,无最大前后缀,故next值为0.
    • t[0]==t[1] next[1]为1, 假设此时为XX,最大前后缀为X,故next值为1.

    得出next[1]=0;

    模式串t

    A

    B

    A

    B

    A

    A

    下标

    0

    1

    2

    3

    4

    5

    next

    0

    0

    3.求解next[2],

    • t[0]!=t[2] next[2]为0; 假设此时为XYZ,前缀为 XY,后缀为YZ,无最大前后缀,故next值为0.
    • t[0] == t[2] next[2]为1; 假设此时为XYX,前缀为XY,后缀为YX,最大前后缀为X,故next值为1.

    在该题中,的next[2]=1

    模式串t

    A

    B

    A

    B

    A

    A

    下标

    0

    1

    2

    3

    4

    5

    next

    0

    0

    1

    4.求解next[3]

    在该题中,next[3]代表t[0]~t[3]即"ABAB"的最大前后缀,即"AB",长度为2.

    在求next[3]时,如何用代码求

    • t[next(3-1)]=t[3]:next[3] = next[next(3-1)+1]+1;

    疑问:为什么求next[3]要把t[3]与t[next(3-1)]做对比,

    首先我们要明白next[3]是什么,next数组的值是代表着字符串的前缀与后缀相同的最大长度,(不能包括自身),

    所以next[3]代表的是t[0]~t[3],这四个字符放入前缀与后缀相同的最大长度

    t[next(3-1)]=t[1],为什么要将t[3]和t[1]对比,也就是t[3]与t[next(2)]对比,这是我之前搞不懂的一个地方!!!!

    然后看了一些大佬的图解似乎好像仿佛明白了。

     

    模式串t

    A

    B

    A

    B

    A

    A

    下标

    0

    1

    2

    3

    4

    5

    next

    0

    0

    1

    我们求next[3]的时候,已经求出next[0]~next[2],此时我们知道了next[2]=1,意味着next[2]是代表着字符串的前缀与后缀相同的最大长度为1。

    也就是对于ABA来说,前缀与后缀相同的最大长度为1,这是我们已知的条件,现在我们要知道对于ABAB来说,前缀与后缀相同的最大长度为??????

    对于ABA来说,前缀"AB",后缀"BA",对于ABAB来说,前缀“ABA”,后缀“BAB”,现在我们观察得出结论

    ABAB的前缀和后缀必然分别包含ABA的前缀和后缀,即next[3]字符串的前缀和后缀必然分别包含next[2]的前缀和后缀,

    无论该字符串是何值。

    既然我们已经知道了next[2]=1,代表着ABA的前缀与后缀相同的最大长度为1,那我们计算next[3]的时候,就知道了第一个字符必然是相同的,所以我们无需再比较第一个字符了,(KMP算法就是为了省这一步!!!!),所以我们将t[3]直接与t[1]而不是t[0]比较,若t[3]=t[1],那我们可以直接说next[3]=2=next[1]+1.

    • t[next(3-1)]!=t[3]:怎么办? 看下面,这就是KMP算法的精髓
    void makeNext(char s[],int next[])
    {
        int len = strlen(s);
        next[0]=0;                    //初始化
        for(int i=1,k=0;i<len;i++)
        {
            while(k>0 && s[k]!=s[i])  //这个while是最关键的部分
                k=next[k-1]; 
                //等价于  k=next[next[i-1]-1]
                //等号右边的k起的只是下标的作用
            if(s[k]==s[i])            
                k++;                  //相等就+1
            next[i]=k;                //赋值
        }
    }

     

    在该题中,t[0]="A",t[3]="B",显然不相等,

    所以需要用该算法

    如何求next[3]呢,将t[3]与t[next(3-1)]对比

    即t[3]与t[next[2]]=t[1]做对比,

    此时t[3]="B",t[1]="B",满足t[3]=t[next(3-1)],next[3]=next[t[[next(3-1]+1]+1;

    得到t[3]=next[1+1]+1=1+1=2;

    模式串t

    A

    B

    A

    B

    A

    A

    下标

    0

    1

    2

    3

    4

    5

    next

    0

    0

    1

    2

    PS:这里为了理解可以推广为,若经过KMP算法得到t[3]=t[0],则next[3]=next[0+1]+1,若经过KMP算法得到t[4]=t[2],则next[4]=next[2+1]+1

    (可以记忆为---里面加1外面也要加1)

    这个时候我们虽然把next[3]计算出来了,但是肯定有人问了,要是t[3]与t[next(3-1)]还是不相等怎么办?????

     

    这个时候我们举另外一个例子

    A B A B A B A C

    0 1 2 3 4 5 6 7

    next[6] = 5

    即前缀为t[0]~t[4] A B A B A

    后缀为t[2]~t[6] A B A B A

     

    next[4] = 3

    即前缀为t[0]~t[2] A B A

    后缀为t[2]~t[4] A B A

     

    next[4]的前缀一定是next[6]的前缀

    next[4]的后缀也一定是next[6]的后缀

     

    现在我们要求next[7],将t[7]与t[next(7-1) ] 比较(此时t[next(7-1)]=t[5]),发现还是不相等

    那么可以将t[7]与t[next(next(7-1)-1)]比较 (此时t[next(next(7-1)-1)]=t[3]),如果相等,则next[7] = next[3+1] +1;

     

    (同前面所述一样,里面加1,外面也加1)

    不相等就重复此过程,直到t[7]与t[0]比较.

    好了,关于KMP算法我们已经通过例题全部解释了一遍,此时这个例子还没有算完,我们通过KMP算法得出最终结果来验证是否KMP算法是否可靠

    模式串t

    A

    B

    A

    B

    A

    A

    下标

    0

    1

    2

    3

    4

    5

    next

    0

    0

    1

    2

    这个时候求next[4]

    1.判断t[4]与t[next(4-1)]是否相等 ,t[4]="A",t[next(4-1)]=t[2]="A"

    2.next[4]=next[2+1]+1=2+1=3

    再求next[5]

    1.判断t[5]与t[next(5-1)]是否相等,t[5]="A",t[next(5-1)]=t[3]="B";

    2.由于t[5]与t[next(5-1)]不相等,所以要继续循环,

         2.1 判断t[5]与t[next(next(5-1)-1)]是否相等,t[5]="A",t[next(next(5-1)-1)]=t[next(3-1)]="B";

         由于t[5]与t[next(next(5-1)-1)]还是不相等,继续循环

                       2.1.1 判断t[5]与t[next(next(next(5-1)-1))-1]是否相等,t[5]="A",t[next(next(next(5-1)-1))-1]=t[next(1-1)]=t[0]="A";

                       此时满足t[5]与t[next(next(next(5-1)-1))-1]相等,所以next[5]=next[0+1]+1=1(记忆口诀为里面加去,外面也加1)

    模式串t

    A

    B

    A

    B

    A

    A

    下标

    0

    1

    2

    3

    4

    5

    next

    0

    0

    1

    2

    3

    1

    这个时候我们就得到了完整的表格

    与我们用非代码计算出来的结果对比

    可以发现,用KMP算法所得的结果是可靠的。

    下面附上kmp完整代码

    #include<iostream>
    #include<algorithm>
    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    
    using namespace std;
    
    void makeNext(char s[],int next[])
    {
        int len = strlen(s);
        next[0]=0;
        for(int i=1,k=0;i<len;i++)
        {
            while(k>0 && s[k]!=s[i])
                k=next[k-1];
            if(s[k]==s[i])
                k++;
            next[i]=k;
        }
    }
    
    int kmp(char t[],char s[])
    {
        int len1 = strlen(t);
        int len2 = strlen(s);
        int next[len2];
        makeNext(s,next);
        for(int i=0,j=0;i<len1;i++)
        {
            while(j>0 && t[i]!=s[j])
            {
                j=next[j-1];
            }
            if(t[i]==s[j])
                j++;
            if(j==len2)
                return i-j+1;
        }
    }
    
    int main()
    {
        char t[]="1234561123458412";
        char s[]="611";
        cout<<t<<endl;
        cout<<s<<endl;
        cout<<"下标为"<<kmp(t,s)<<endl;
    }
    
    

     

    展开全文
  • kmpnext数组

    2020-11-10 18:07:06
    关于kmp算法中next数组kmp算法中next数组的两种法的简单解释 第一种:使用找出子前缀和子后缀中公共部分的最大长度来求next数组kmp算法就是为了加快模式匹配,而next数组就是加快模式匹配的关键,而核心就是公共...
  • KMP算法 next数组 nextval数组

    千次阅读 2020-02-20 20:55:49
    文章目录KMP算法简介KMP算法过程next数组的定义及实现next数组实现代码next数组的改进KMP算法的代码实现 KMP算法简介 KMP算法是一种改进的字符串匹配算法,由D.E.Knuth,J.H.Morris和V.R.Pratt提出的,因此人们称它...
  • kmpnext数组

    2017-08-11 00:36:38
    kmpnext数组next 数组的作用是很强的,但是我只能说,理解它的作用,并不能说完全掌握,我先在想通过两道题,来找点那种next 数组,如果只通过他,我能干些什么。一开始,我对kmp算法的理解,很浅,认为只是用来...
  • KMP算法 Next数组

    2018-07-25 12:21:17
    相信很多人在求解next数组时遇到了瓶颈,各种博客论坛的解决方案也各不相同,有的甚至是错误的,那么next数组到底是怎么的呢? 1.在求next数组之前,首先我们“公有元素个数”,之后next会用到。 举个例子...
  • KMPnext数组实现

    2019-04-16 15:39:53
    KMPnext数组实现 #include <iostream> using namespace std; int main() { char a[] = {'a','b','c','d','a','b','d'}; int next[7]; next[0] = 0; int j = 0; int i = 1; while( ...
  • KMP —— next数组

    2017-02-14 18:15:13
    KMP算法中next数组
  • 输入的abababb 但是用这个求next数组不对
  • KMP算法next 数组求解

    2021-08-09 18:46:26
    KMP算法next数组求解 ** 要求那个next数组(有些叫next-val数组): 1.必须先模式串S 每一个字符前面的那个字符串的最大公共前后缀长度,将这一系列长度存成一个数组,出来的每个长度其实就是和模式串每一个对应...
  • POJ 2725 KMPnext数组

    2018-08-11 15:45:14
    KMP,考的就是KMPnext数组的具体含义。 如果不理解next,可以参考这篇博客:KMPnext数组含义 AC代码: #include &lt;iostream&gt; #include &lt;cstring&gt; #include &lt;cstdio&...
  • HDU 3336 KMPnext数组

    2018-08-11 15:32:35
    KMP,考的就是KMPnext数组的具体含义。 如果不理解next,可以参考这篇博客:KMPnext数组含义 AC代码: #include &lt;iostream&gt; #include &lt;cstring&gt; #include &lt;cstdio&...
  • KMP算法求next数组

    2019-08-27 21:56:42
    KMP算法中有个数组,叫做前缀数组,也有的叫...这个next数组法是KMP算法的关键,但不是很好理解,我在这里用通俗的话解释一下,看到别的地方到处是数学公式推导,看得都蛋疼,这个篇文章仅贡献给不喜欢看数...
  • KMPnext数组定义

    2018-11-12 13:26:10
    KMP算法的Next数组详解 转载请注明来源,并包含相关链接。 网上有很多讲解KMP算法的博客,我就不浪费时间再写一份了。...KMPnext数组求法是很不容易搞清楚的一部分,也是最重要的一部分。我这篇文章就...
  • KMPnext数组详解

    千次阅读 2018-05-22 19:42:04
    KMPnext数组简单来说,假设有两个字符串,一个是待匹配的字符串strText,一个是要查找的关键字strKey。现在我们要在strText中去查找是否包含strKey,用i来表示strText遍历到了哪个字符,用j来表示strKey匹配到了...
  • KMPnext数组求

    2019-07-29 08:54:55
    直接来说KMP最难做的Next数组吧。 先来一个字符串,ababa 本篇文章用的next【0】是-1的 序号 0 1 2 3 4 5 字符串 a b a b a next -1 0 接下来说怎么吧, next[0]=-1,next[1]=0 这个不用多说了吧? 开始比较, nex...
  • HDU 2594 KMPnext数组

    2018-08-11 15:27:59
    KMP,考的就是KMPnext数组的具体含义。 如果不理解next,可以参考这篇博客:KMPnext数组含义 AC代码: #include &lt;iostream&gt; #include &lt;cstring&gt; #include &lt;cstdio&...
  • Kmpnext数组含义

    千次阅读 2018-07-13 14:48:55
    这篇分析了Kmpnext数组到底是用来干什么的。文章假定大家已经对字符串匹配算法具有初步了解。但是对kmp中的next不是很懂。如果想要研究更多。可以出门左转...
  • KMP算法Next数组计算

    万次阅读 多人点赞 2012-10-31 21:18:29
    2次都是让求Next函数的序列(其实是)。先看看题吧。 (2011年下半年上午题) (2012年上半年上午题) 其实做这个题很简单,我先说说这个题里的各种概念。 给定的字符串叫做模式串T。j表示next函数的参数,其...
  • KMP算法next数组详解

    千次阅读 2017-02-02 17:48:09
    这里的已匹配信息叫做部分匹配表,也叫做next数组。其存储的是字符串的前缀后缀重合部分的字符数。以此来控制模式串的移动位数。next数组生成的步骤: 假设模式串是“ABABABB” 前缀:除最后一个字符外,例如,A、...
  • 目录 Count the string (KMPnext数组 的使用) 题目 题意 思路 题解 Count the string (KMPnext数组 的使用) 题目 It is well known that ...
  • 题目分析:因为n给的很大,所以肯定不能暴力判断了,我们可以巧妙的利用kmpnext数组进行判断,next数组有一个挺重要的性质: n-next[n]是在当前n位置时的最大循环节长度 有了上述结论,在跑出next数组后,就不难...
  • KMP求next数组理解: 模式串(子串)的第i个字符对应的next(i)应该是比较第i-1个字符是否与next(i-1)相等,如果相等则说明它能与next(i-1)所在的字串相对应。
  • KMPnext数组的理解

    2016-10-17 19:15:25
    对于KMP算法中的next数组大家估计都不是很陌生。 但是,next数组的意义好像是一知半解。不过next数组的博大精深 一般的next求解: next[ ]数组 void Get_Next(){ next[0]=-1;

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,412
精华内容 9,764
关键字:

kmp求next数组