#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号元素。
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
这么一来要判断要简单多了,只需要
2 unsigned dst //代表较少元素数组的编码
3 if (src & dst == dst)
4 return true;
5
6 return false;
但是且慢,如何将1 2 3 4等元素存入 src 之类变量?
So, 手工加工的 table登场
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 };
只需要每数组扫描一遍即可实现目标。
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
可按下图来考虑
0 1
. .
. .
. .
31 32
32 -- 0 1
. .
. .
. .
63 -- 31 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.
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?