问题描述

对于一个给定的 source 字符串和一个 target 字符串，你应该在 source 字符串中找出 target 字符串出现的第一个位置(从0开始)。如果不存在，则返回 -1。

问题分析

之前在考验复习数据结构的时候就被这道题困了好久，书本上介绍的是KMP算法（大家戏谑的说说“看毛片”Q^Q），这个算法可谓是考验智商，反正我看了N遍也没有看明白，最后只能死记，到最后打算遇到了就放弃好了。现在OJ的时候又看到了这道题，我觉得现在的我已经是研究生了，不能怂，一个字，就是“干”。可是，还是看不懂！直到今天上午看到一个magic的算法，叫做Rabin-Karp，天哪，比KMP算法简单易懂上百倍。不明白为什么教材上不介绍这个算法，是为了证明我们读者有多傻叉吗？！天知道。好了，废话不多说，我们现在好好介绍一下我们可爱乖巧的Rabin-Karp吧（好激动~~~~）

先看维基百科对于Rabin-Karp 的定义：

Rabin-Karp is a good example of a randomized algorithm(if we pick M in some random way).We get no guarantee the algorithm runs in O(n+m)time, because we may get unlucky and have the hash values regularly collide with spurious mathces. Still, the odds are heavily in out favor-if the hash function returns values uniformly from 0 to M-1, the probability of a false collision should be 1/M.This is quite reasonable:ifM=.n,there should only be one false collision per string.and if M = n^k for k>=2, the odds are greate we will never see any false collisions.

实际上，Rabin-Karp是使用hash的原理来进行字符串匹配的。hash算法最关键的地方是找到一个hash函数。而Rabin-Karp的关键也在此。算法的主要思想是将字符串通过哈希运算，映射为一个整数。比如说：
字符串“bcedf”, 使用哈希方程得到val=[b*31^4+c*313+e*31^2+d*311+f*31^0]mod1000000;(这里式子中的b,c,e,d,f都是字符，因为它们都各自对应于一个ASCII码，所以不需要进行处理，结果得到的是一个非整数。式子中的31可以看作是一个“基数”，这个“基数”的选择可以是其他的，但是31是一个经验值，事实证明这个值也很好。由于)
通过这样一个hash函数，可以将每一个字符串对应到一个整数。所以当target字符串得到的hash值和source中某一子串的hash值一样时，就有可能是匹配的，（这里注意一下，是有可能匹配，最后到底是不是匹配还要将两个字符串逐一比较。这是因为hash函数的性质：不同的字符串可能得到相同的hash值）

其实，Rabin-Karp算法真正改进的原因是在，当某一字符串与target不匹配的时候，需要移动到下一个字符串继续进行比较。传统算法这一步的时间复杂度是O(n)，但是如果使用Rabin-Karp算法，可以把算法的时间变为O(1).具体的实现如下：
　　比如说，source字符串为“abcdc”，target字符串为“bcd”，第一次匹配字符串“abc”和“bcd”不匹配，接下去就要匹配“bcd”，那么从“abc”变为“bcd”，使用Rabin-Karp算法，我们可以这么做：
hash(abc)=a*31^2+b*311+c*31^0;
hash(bcd)=hash(abcd)-a*31^3.

代码实现：

class Solution {
public:
    /**
     * Returns a index to the first occurrence of target in source,
     * or -1  if target is not part of source.
     * @param source string to be scanned.
     * @param target string containing the sequence of characters to match.
     */
    static const int BASE=100000;
    int strStr(const char *source, const char *target) {
        // write your code here
        /*int m = sizeof(target) / sizeof(target[0]) - 1;
        int n = sizeof(source) / sizeof(source[0]) - 1;*///这个地方是一个坑，后面会提到
        if(source == NULL || target == NULL)//异常检测
            return -1;
        int m = strlen(target);
        int n = strlen(source);
        if(m == 0) 
            return 0;
        long long power = 1;
        for(int i = 0;i < m;i++)
        {
            power = (power * 31) % BASE;//这个31，不一定是31，可以看成是一个经验值
        }
        long long targetval = 0;
        for(int i = 0;i < m;i++)
        {
            targetval = (targetval * 31 + target[i]) % BASE;//算出的是target的hash值
        }
        long long hashval = 0;
        for(int i = 0;i< n;i++)
        {
            hashval=(source[i] + hashval * 31) % BASE;
            if(i < m - 1)//注意这里是m-1，不是m。因为当i=m-2的时候，continue，i++以后，i变为了m-1
            {
                continue;
            }
            if(i >= m)
            {
                hashval = (hashval - source[i - m] * power)% BASE;
                if(hashval < 0)
                {
                    hashval +=BASE;//判断一下上面得到的hashval是不是为负值
                }
            }
            if(targetval == hashval)
            {
                int j = 0;
                for(;j < m;j++)
                {
                    if(target[j] == source[i - m + j + 1])
                        continue;
                }
                if(j == m)
                    return i-m+1;
            }
        }
        return -1;
    }
};

这里有很多细节需要注意：

首先：我们发现有这个hash函数的数值很大，有31的幂指数的运算，如果不作处理就会超过long long类型的最大表示范围。所以我们这里一遍×31的幂指数，一遍进行取模操作。同样的，我们在计算字符串的hash值的时候，也采用边循环边取模的操作。
　其次：在程序中起始的地方，要求传进来的字符数组的长度。刚开始我是采用了

int m = sizeof(target) / sizeof(target[0]) - 1;
int n = sizeof(source) / sizeof(source[0]) - 1;

的操作。这里有一个很重要的知识盲点，就是sizeof（）这一个函数，在这里，target和source都是函数传递进来的指针，这时候使用sizeof(target)其实求的是target这一个指针的长度，在计算机当中，指针类型的长度为4个字节，所以程序这么写是不对的。正确的写法是，采用

int m=strlen(target);