字符串匹配

1. KMP

个人觉得KMP理解起来需要一点时间，思路  http://en.wikipedia.org/wiki/Knuth–Morris–Pratt_algorithm 上面描述的非常清楚

首先要做的是建表，直观的理解就是把needle分割，这样每次匹配断掉的时候，利用这个table来找到下一个需要匹配的位置

例如：

建表的方法：两个变量pos用来遍历T， cnd：current candidate的值

匹配：

needle的idx: i

haystack的idx: m+i

if needle[i] == haystack[m+1]    i++

else 

m += i - T[i];

        i  = T[i];

其实复杂度就很好分析了 O(needle.size() + haystack.size())

class Solution {
public:
    char *strStr(char *haystack, char *needle) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        
        int N = 0, K = 0;
        char *p = haystack;
        while(*p){ 
            p++;
            N++;
        }
        p = needle;
        while(*p){
            p++;
            K++;
        }
        
        if(K == 0) return haystack;
        
        //KMP_table building
        vector<int> T(K, 0);
        T[0] = -1;
        
        int pos = 2, cnd = 0;
        while(pos < K){
            if(needle[pos - 1] == needle[cnd]){
                cnd++;
                T[pos] = cnd;
                pos++;
            }else if(cnd > 0){
                cnd = T[cnd];
            }else{
                T[pos] = 0;
                pos++;
            }
        }
        
        //matching
        int m = 0, i = 0;
        while(m + i < N){
            if(needle[i] == haystack[m+i]){
            //match
                if(i == K-1){
                    return haystack+m;   
                }else i++;
            }else{
            //not match
                m += i - T[i];
                if(T[i] > -1) i = T[i];
                else i = 0;
                
            }
            
        }
        return NULL;
        
        
    }
};

2. 二维字符串匹配

查了一下，一般来说可以用KR算法

http://www.cnblogs.com/longdouhzt/archive/2011/10/05/2199271.html 这里讲得蛮清楚的，面试中也被面到了这个算法

若小矩阵的尺寸为m1 * m2, 大矩阵的尺寸为n1 * n2

上面一个算法的时间复杂度应该是O( (m1 + n1) * n2 + m1 * m2 )