shift-And / shift-Or 算法

原文链接：http://www.cnblogs.com/longdouhzt/archive/2011/09/25/2190550.html

Shift-And算法思想较之KMP算法很简单，设模式字符串为P，它主要通过保存一个集合D（D中记录了P中所有与当前已读text的某个后缀相匹配的前缀），每当text有新的字符读入，算法利用位并行机制来更新这个集合D。

　　设P长度为m，则集合D可表示为D = dm…d1 而用D[j]代表dj

　　D[j]=1当且仅当p1…pj 是 t1…ti 的某个后缀，当D[m]=1时，就认为P已经于text匹配。

　　当读入下一个字符 ti+1, 需要计算新的集合 D′. 当且仅当D[j]=1并且  ti+1 等于 pj+1时D'[j+1]=1. 这是因为D[j]=1时有 p1…pj 是 t1…ti 的一个后缀，而当ti+1 等于 pj+1可推出p1…pj +1是 t1…ti+1 的一个后缀.这个集合可通过位运算来更新.

　　算法首先建立一个数组B, 数组长度为text串所属字符集长度（例如A-Z的话数组B的长度为26.）  如果P的第j为等于c则将B[c] 中第j位置为1.

因为要预处理计算B，如果字符集很大的话，并不划算。如果m很长的话（大于机器字长），也很不方便。所以这种算法适用于字符集较小，模式串小于机器字长的情况。当然对于模式串较长的情况，也是比brute force要快的，只是逻辑上要复杂些。

　　Shift-And的代码如下，这里假设字符集的大小为128

int shift_and(char * s, int len_s, char * p, int len_p)
{
     int B[128];
     memset(B, 0, sizeof(B));

     int i;
     for (i=0; i<len_p; i++)
        B[p[i]] |= 1<<i;

     int D = 0;
     for (i=0; i<len_s; i++)
     {
        D = ((D<<1) | 1) & B[s[i]];  //D<<1与1位或操作，是可以让匹配随时从当前字符开始，使用位运算实现了并行
        if (D & (1<<(len_p-1)))
         return i - len_p+1;
     }
     return -1;
}

Shift-Or算法跟Shift-And算法思想是一样的，只是在通过取补，减少了位运算的次数，提高了速度。Shift-Or作的修改是，用零表示一个数在集合里，1表示不在，所以

D = ((D<<1) | 1) & B[s[i]];

修改为D=D<<1 | B[s[i]]; 省了一次位运算，当然B和D的初始化的时候，也要作相应的修改。

====================================================================

My Code：

Shift-And

int size = 128; // 此处默认字符集规模为128

//预处理，
void preShiftAnd(const char *p, int m, unsigned int *s){
    for(int i=0; i<size; i++)
        s[i] = 0;
    for(int i=0; i<m; i++){
        s[p[i]] |= 1<<i;
    }
}

//Shift—And
int ShiftAnd(const char *t, const char *p){
    int tLen = strlen(t);
    int pLen = strlen(p);
    unsigned int state = 0;            //即D数组
    unsigned int s[size];

    if(tLen < pLen) return -1;

    preShiftAnd(p, pLen, s);     //预处理

    for(int i=0; i<tLen; i++){
        state = ((state<<1)|1) & s[t[i]];
        if(state & 1<<(pLen-1))            //最高位出现零
            return i - pLen + 1;
    }
    return -1;

}

Shift-Or

#define WORDSIZE sizeof(int)*8 
#define ASIZE 256                                    // 只考虑ASCII码字符集

int preSo(const char *x, int m, unsigned int S[]) { 
    unsigned int j, lim; 
    int i; 
    for (i = 0; i < ASIZE; ++i) 
        S[i] = ~0;                                    // 初值都是全1的二进制数
    for (lim = i = 0, j = 1; i < m; ++i, j <<= 1) { 
        S[x[i]] &= ~j;                                // 当第 J 位为 I 的时候, S[I][J] = 0;
        lim |= j; 
    } 
    /*
    for (i = 0; i < m; i++) { 
        cout << x[i] << " Feature " << bitset<sizeof(int)*8>( S[x[i]]) << endl;
    } 
    */
    lim = ~(lim>>1); 
    return(lim); 
} 

int SO(const char *x, int m, const char *y, int n) { 
    unsigned int lim, state; 
    unsigned int S[ASIZE]; 
    int j; 
    if (m > WORDSIZE) { 
        cout << "SO: Use pattern size <= word size"; 
        return -1;
    }

     /* Preprocessing */ 
     lim = preSo(x, m, S); 

     /* Searching */ 
     for (state = ~0, j = 0; j < n; ++j) { 
         state = (state<<1) | S[y[j]]; 
             if (state < lim) 
                 return j - m + 1; 
         } 
     return -1;
} 

原文链接：http://www.douban.com/note/321872072/

Shift-And/Shift-Or 算法和KMP 算法一样，也是线性时间复杂度的字符串匹配算法，运行时间上甚至要比KMP 算法快得多。而理解上比KMP 算法更容易一些。Shift-And/Shift-Or 算法设计的非常巧妙，初次接触时同样“吓了一跳”。
Shift-And 与 Shift-Or 算法的原理完全一样，区别仅在于Shift-Or 对Shift-And 做了一点儿改进。我们先说Shift-And 算法。

与上一篇透彻理解KMP算法 中描述的问题相同，S 表示原字符串，T 表示目标串（模式串），我们要在S 中搜索T。
令 S[0..m-1] = abcabcabdabba, T[0..n-1] = abcabd

1，Shift-And 算法思想
Shift-And 算法的核心思想是利用掩码D 来记录模式串的前缀匹配情况。（瞧，shift 算法的核心也是前缀匹配）。Shift 算法大量应用了位运算。
D 是一个m 位的无符号整数：D[n-1, n-2, ..,1,0] （注意D 并不是一个数组，仅仅是一个整数，D[n-1] 表示其最高位bit）。
数组索引i 控制S 串的扫描，当扫描的字符S[i] 时，D 的第j 位D[j] = 1 当且仅当T[0..j] 是S[0..i] 的一个后缀。

要使用Shift 算法，需要一个辅助表B。B 是一个字典，key 是问题域字符集中的每个字符，value 是一个n 位无符号整数，记录该字符在模式串T 的哪些位置出现。
例如，字符c 在T[2] 处出现，那么B['c'] = 000100 （对于字符串，低位在左；对于B['c']，低位在右）；同理，a 在T[0],T[3] 处出现，B['a'] = 001001.

假设当前处理到S[i]，需要对D 进行更新。由于D[j] (0<j<n) 标识T[0..j] 是否是S[0..i] 的后缀，所以D[j]=1 当且仅当更新前的D[j-1]=1 并且S[i]==T[j]；D[0] 是边界情况，D[0]=1 当且仅当S[i]==T[0]。
所以，D = (D << 1 | 1) & B[S[i］ ;
显然，当D[n-1]=1 时，表示T[0..n-1] 是S[0..i] 的后缀，此时找到一个T的完全匹配。

2，Shift-And 算法实现
Shift-And 匹配过程代码：

由于位运算在计算机中可以并行进行，每次循环的执行是常数时间的，所以上面代码段的复杂度是 O(m)。

3，辅助表 B
上面没有提到如何得到辅助表B。很简单，只要获得模式串T 中每个字符出现的位置。

显然，上述代码段的复杂度是 O(n)。Shift-And 算法的时间复杂度是O(m+n)。
实际上，shift 算法通常比KMP 算法的匹配速度要快，因为计算机位并行运算是非常高效的。

注意：数组B 的大小是由字符集决定的，如果字符来自ASCII 码，字符的数值范围是0~127，数组大小是128 即可；否则，可能需要更大的数组B，或者自己构建字符到整数索引之间的散列关系。

4，Shift-Or 算法
在Shift-And 中，对掩码D 的更新：D = (D << 1 | 1) & B[S[i］ ;
每次更新D 都需要额外进行D 移位后与"1" 的"或"运算。这是由于我们要保证当字符S[i] 在T[0] 处出现时，D[0] 一定要等于1，而D 向左移位后最低位是0。

如果将Shift-And 中核心的“与” 运算改为“或” 运算，可以节省这一个附加的“或1” 运算。这正是Shift-Or 所改进的地方。
Shift-Or 与Shift-And 的唯一区别在于，在Shift-Or 中，“有效位” 是通过0（而不是1）来标识。
于是求解辅助表B 和更新掩码D 都会与Shift-And 有一些区别，详见代码。

Shift-And 完整代码： C++ 实现 Python 实现
Shift-Or 完整代码： C++ 实现 Python 实现

原文链接：http://www.cnblogs.com/ACystalMoon/archive/2012/12/30/2839293.html

这个算法利用了位运算的优势速度很快，易于实现，缺点是模式串不能太长。据说在适用范围内速度是kmp的至少2倍。算法思想是用一个数字prefix的二进制去表示模式串的前缀，prefix的二进制第i位表示模式串的前缀0～i。如果这个前缀i是当前搜索到的匹配串的后缀时，将第i位至1。算法就是从匹配串的第0个字符到最后一个字符不断更新prefix的值每次更新后看最长的前缀（即模式串）的位是否被至1，如果是说明得到了一个匹配。

　　下面说明下更新的过程。假如求出了比较匹配串第j位时的prefix，现在求比较j+1位的情况：prefix第i位为1当且仅当prefix第i-1位为1（匹配了i-1个字符），并且第i位所在字符和匹配串第j+1个字符相等。按下面实现来说，每次循环将prefix左移一位，第0位至一，在&上一个代表第i个字符是否匹配模式串某位的数字（这个通过初始化得到），就得到更新后的prefix。

　　shiftAnd和shiftOr的思想一致。只是实现时存的是反码，因为prefix左移自然引入第0位的是0，为了减去或运算，才引入反码表示。

上代码～

 1 //return a hashtable 代表字母表中的各个元素是否能成为模式串的后缀，用64位位压缩表示
 2 long long * initAlphbat(char *patternString)
 3 {
 4     long long *hash = (long long *) malloc(256 * sizeof(long long));
 5     unsigned int idx = 0;
 6     int psLen = strlen(patternString);
 7 
 8     if(hash == NULL) return NULL;
 9 
10     memset(hash, 0, 256 * sizeof(long long));
11     for(idx = 0; idx < psLen; ++idx)
12     {
13         hash[(unsigned int)patternString[idx]] |= ((long long)1 << idx); //表示patternString[idx]代表字符可以是在模式串的哪些位置
14     }
15 
16     return hash;
17 }
18 
19 //the patternString length must be less than 64
20 MatchingInfo * ShiftAnd(char *patternString, char *dataString, unsigned int dsLen)
21 {
22     unsigned int idxDs = 0, psLen = strlen(patternString);
23     long long *hash = initAlphbat(patternString);
24 
25     long long prefix = 0;  //每一位表示一个模式串的前缀，如果该位是1则表示当前该前缀被匹配上
26 
27     if(hash == NULL) return NULL;
28 
29     //匹配信息的初始化
30     MatchingInfo *mi = (MatchingInfo *)malloc(sizeof(MatchingInfo));
31     if(mi == NULL) return NULL;
32     mi->indexOfMatch = (unsigned int *)malloc(sizeof(unsigned int));
33     mi->numOfMatch = 0;
34     mi->allocLen = 1;
35 
36     //下面的循环中动态更新prefix
37     for(idxDs = 0; idxDs < dsLen; ++idxDs)
38     {
39         prefix = (prefix << 1) | 1;
40         prefix &= hash[(unsigned int)dataString[idxDs]];
41         if(prefix & ((long long)1 << (psLen - 1)))
42         {
43             //匹配上一个模式串
44             if(mi->allocLen > mi->numOfMatch)
45             {
46                 //记录下标的内存够用
47                 mi->indexOfMatch[mi->numOfMatch++] = idxDs - psLen + 1;
48             }
49             else
50             {
51                 //扩张匹配下标的内存
52                 mi->indexOfMatch = (unsigned int *)realloc(mi->indexOfMatch, (mi->allocLen << 1) * sizeof(unsigned int));
53                 mi->allocLen <<= 1;
54                 mi->indexOfMatch[mi->numOfMatch++] = idxDs - psLen + 1;
55             }
56         }
57     }
58 
59     free(hash);
60     hash = NULL;
61     return mi;
62 }

LINK ： http://www.cnblogs.com/Kenfly/archive/2011/07/22/2114108.html

Shift-And 与 Shift-Or算法

当模式字符串长度数比机器字短和总字符集个数比较少时，Shift-And与Shift-Or算法平均效率是KMP的两倍，下面是Shift-And算法，Shift-Or是同样我思想，只不过用位0表示真状态

 1 #include <cstdio>
 2 #include <cstring>
 3 
 4 void shiftAnd(char *t, char *p)
 5 {
 6     int lenP = strlen(p);
 7     int b[26] = {0};
 8     for(int i = 0; p[i]; ++i)
 9     {
10         b[p[i] - 'a'] |= 1 << i;
11     }
12 
13     int status = 0;
14     for(int i = 0; t[i]; ++i)
15     {
16         status = ((status << 1) | 1) & b[t[i] - 'a'];
17         if(status & (1 << (lenP - 1)))
18             printf("%d\n", i - lenP + 1);
19     }
20 }
21 
22 int main()
23 {
24     char T[100];
25     char P[32];
26     scanf("%s%s", T, P);
27     shiftAnd(T, P);
28     return 0;
29 }