集合包含关系的快速算法

#1 每行数据代表一个集合，如何判断集合的包含关系？ -- 集合的数据仅在有限范围内。

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23       a --24个元素
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24     b --24个元素

最容易想到的是蛮力运算，计算前还应该知道谁元素多，对吧？不过还好，我耍了个花招，在读取数据时已经把数组元素数目存入数组第0号元素。

1  for each element x  in a
2      if (!setContain(b , x))
3         return  false;
4 
5  return  true;    

#2 数据在31以内，考虑用无符号数编码数组
例如 1 2 3 4 用 0x00000000 00000000 00000000 00001111编码，也就是1用第一个bit，2用第二个bit，依此类推...
但是数据里面有0，也好说，0用第一个bit，1用第二个bit，依此类推...
这样1 2 3 4 最终形式 0x00000000 00000000 00000000 00011110
这么一来要判断要简单多了，只需要

1 unsigned src //代表较多元素数组的编码
2 unsigned dst //代表较少元素数组的编码
3  if (src & dst == dst)
4      return  true;
5 
6  return  false;

但是且慢，如何将1 2 3 4等元素存入 src 之类变量？
So, 手工加工的 table登场

 1     unsigned  int table[ 32] = {
 2          0x00000001,  0x00000002,  0x00000004,  0x00000008, 
 3          0x00000010,  0x00000020,  0x00000040,  0x00000080,
 4          0x00000100,  0x00000200,  0x00000400,  0x00000800, 
 5          0x00001000,  0x00002000,  0x00004000,  0x00008000,
 6          0x00010000,  0x00020000,  0x00040000,  0x00080000,
 7          0x00100000,  0x00200000,  0x00400000,  0x00800000,
 8          0x01000000,  0x02000000,  0x04000000,  0x08000000,
 9          0x10000000,  0x20000000,  0x40000000,  0x80000000
10     };

只需要每数组扫描一遍即可实现目标。

1 src = 0;
2
3 for each element x in a
4     src = src + table[x];

问题基本解决。

#3 考虑如下数组：如何扩展至64位

25 26 27 28 29 30 31 32 33 34 35 36 37 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
26 27 28 29 30 31 32 33 34 35 36 37 38 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

可按下图来考虑

number      bit
0            1
.           .
.           .
.           .
31           32


32 --  0      1
.           .
.           .
.           .
63 --  31     32

再构造数组

1  int cache = { 0,  32};
2 unsigned  int cacheManager[ 2][ 2];
3  // 用二维数组维护两个数组的编码，每行编码一数组

方法如下，分别以16  ， 63为例

运算 (16 & 0x00000020) >> 5 得出  0，  然后 16 - cache[0] 得出 16,   16 存入cacheManager[?][ 0 ]

运算 (63 & 0x00000020) >> 5 得出  1，  然后 63 - cache[1] 得出 31,    31存入cacheManager[?][ 1 ]

#4 实际代码，利用此方法，程序运行时间缩短到原来1/3.

 1  int fillCacheManager(normalInt * index, Element (* dt)[ElementNumber], unsigned  int (*cm)[cacheLine], unsigned  int * table){
 2      int element;
 3      int cache[ 2] = { 0 ,  32};
 4      int serial;
 5 
 6      for( normalInt m= 1; m<=index[ 0]; m++ ){
 7         normalInt t = index[m];
 8         cm[t][ 0] =  0;
 9         cm[t][ 1] =  0;
10          for ( normalInt n= 1; n<=dt[t][ 0]; n++  ){
11             element = dt[t][n];
12             serial = (element &  0x00000020) >> 5;
13             element = element - cache[serial];
14             cm[t][serial] = cm[t][serial] + table[element] ;
15         }
16     }
17 
18      return  0;
19 }
20 
21 
22  int quickTableReducton(normalInt * index, Element (* dt)[ElementNumber], unsigned  int (*cm)[cacheLine]){
23     normalInt subset = index[ 0];
24      if (subset ==  0)  return - 1;
25     
26      for (normalInt m= 1; m<subset; m++ ){
27          if (index[m] <  0)  continue;
28         
29          for(normalInt n=m+ 1; n<subset+ 1; n++){
30              if(index[n] <  0)  continue;
31              if(n == m)  continue;
32 
33             normalInt src = index[m];
34             normalInt dst = index[n];
35             normalInt QQ = dst;
36              bool swaped =  false;
37              if (dt[src][ 0] < dt[dst][ 0]){
38                 swaped =  true;
39                 QQ = src;
40             }
41 
42              if (  (cm[src][ 0] & cm[dst][ 0]) == cm[QQ][ 0]    &&   (cm[src][ 1] & cm[dst][ 1]) == cm[QQ][ 1]  ){
43                  int t = m;
44                  if (swaped) t = n;
45                 index[t] = - 2; 
46                 index[ 0] = index[ 0]- 1;
47                  if (swaped ==  false)  break;            
48             }
49         }
50     }
51 
52     normalInt idx[indexCount]; // indexOver
53      normalInt len= 1;
54      for (normalInt m= 1; index[m]!=indexOver; m++) // m<=index[0]
55           if (index[m] > - 1){
56             idx[len] = index[m];
57             len++;
58         }
59 
60      for (normalInt m= 1; m<len; m++) index[m] = idx[m];
61     index[len] = indexOver;
62 
63      return  0;
64 }

#5 STL bitset : better choice?