Algorithm 如何生成块中的组合

Algorithm 如何生成块中的组合,algorithm,combinations,Algorithm,Combinations,我有一个算法,可以对输入元素的每个组合执行计算,例如,100个元素集中的每个5元素子集。我正在将它移植到GPU,现在我已经准备好了它的初始版本。为了加快速度,我想从本地内存加载数据,本地内存是有限的(例如32KB),可以容纳100个输入元素中的20个。因此,我必须以某种方式划分我的工作,并以块的形式生成组合。现在这是最难的部分,如何做到这一点。很可能我必须首先加载20个元素的数据,然后对这20个元素的5个元素子集执行计算。在此之后,我将不得不用新的替换部分(或全部),并对它们进行计算,然后冲洗并

我有一个算法,可以对输入元素的每个组合执行计算,例如,100个元素集中的每个5元素子集。我正在将它移植到GPU,现在我已经准备好了它的初始版本。为了加快速度,我想从本地内存加载数据,本地内存是有限的(例如32KB),可以容纳100个输入元素中的20个。因此,我必须以某种方式划分我的工作,并以块的形式生成组合。现在这是最难的部分,如何做到这一点。很可能我必须首先加载20个元素的数据,然后对这20个元素的5个元素子集执行计算。在此之后,我将不得不用新的替换部分(或全部),并对它们进行计算,然后冲洗并重复。您能告诉我如何在本地内存中选择替换的元素以避免重复工作吗?到目前为止,我得出的结论是,我必须一次更换至少16个,以避免重复工作的问题

编辑:以下是从5个元素中生成2个元素组合的示例。以下是所有可能案例的完整列表:

1, 2
1, 3
1, 4
1, 5
2, 3
2, 4
2, 5
3, 4
3, 5
4, 5
GPU上的本地内存是有限的-让我们假设它只能容纳3个元素。所以我必须把我的问题分成3个元素中2个元素的组合。我必须重复多次,直到我从上面的列表中得到所有的组合。作为第一步,我可以将元素1、2、3加载到本地内存中,因此我将得到以下组合:

1, 2
1, 3
2, 3
1, 4
1, 5
4, 5
现在我必须加载另一组元素并计算它们的组合。它可以是1,4,5。它将产生以下组合:

1, 2
1, 3
2, 3
1, 4
1, 5
4, 5
另一方面,集合1、2、4无效-它将导致重复组合:

1, 2 // duplicate
1, 4 // ok, new
2, 4 // ok, new
在这一步之后,还有4种组合需要生成(列表如下)。算法必须能够从3个元素中生成另一个2元素组合,并以某种方式处理最后(第10个)组合

2, 4
2, 5
3, 4
3, 5

通过以这种方式拆分工作,我将能够使用有限的本地内存处理原始输入集的所有组合,该内存只能保存其中的一部分。

例如,您有100个元素,您可以在内存中保存20个元素,并且您需要所有5个元素的组合,其中有C(100,5)=75287520

为了能够生成所有的组合,5个元素的每个组合都必须在内存中的某个位置。这可以通过将元素分成20/5=4个元素的组来实现;输入中有25个这样的组,C(25,5)=5个组的53130个组合

对于每个组的组合,我们将首先从五个组中的每个组生成一个元素的组合;这为我们提供了53130 x 45=54405120个独特的组合

我们现在有了组合,其中每个元素来自不同的组,即分区[1,1,1,1,1]。我们仍然需要找到划分[2,1,1],[2,2,1],[3,1,1],[3,2]和[4,1]的组合。最简单的方法是分阶段进行,但最快的方法当然是将它们合并到[1,1,1,1,1]的第一阶段中,因为我们需要的所有组组合都在第一阶段的某个时间加载到内存中

对于分区[2,1,1,1],我们依次加载每个组,作为包含2个元素的组,然后从其余24个组中加载3个组的每个组合,并从每个组中提取一个元素。这将需要25 x C(24,3)=50600个步骤,每个步骤产生C(4,2)x 43=384个组合,或总共19430400个

像[2,2,1]这样的分区有点不同,因为我们会依次加载每个组,使其成为包含2个元素的第一个组,但只加载后面的组,作为包含2个元素的第二个组,以避免重复。然后,对于其中的每一个,我们将加载其他23个组中的每一个,以获得最终的元素。这需要C(25,2)/2 x 23=6900个步骤,每个步骤产生C(4,2)x C(4,2)x C(4,1)=144个组合,总共99.36万个

分区[3,1,1]需要25 x C(24,2)=25 x 276=6900个步骤,每个步骤产生C(4,3)x 42=64个组合,总共441600个

分区[3,2]需要25 x 24=600个步骤,每个步骤产生C(4,3)x C(4,2)=24个组合,总共14400个

分区[4,1]需要25 x 24=600个步骤,每个步骤产生C(4,4)x C(4,1)=4个组合,总共2400个

因此,我们总共有:

[1,1,1,1,1] -> 54,405,120
[2,1,1,1]   -> 19,430,400
[2,2,1]     ->    993,600
[3,1,1]     ->    441,600
[3,2]       ->     14,400
[4,1]       ->      2,400
               ----------
               75,287,520 combinations
正如您所注意到的,分区[3,2]和[4,1]都需要两个组的每次组合,因此它们可以很容易地集成到一个阶段中。当然,如果您将它们全部集成到[1,1,1,1,1]的第一阶段中,您只需将53130个组的组合加载到内存中,这是绝对最小值

(如果在每个步骤中只将一组新的元素加载到内存中更快,而不是按字典顺序运行组的组合,请检查。)


不同阶段的整合

运行分区[1,1,1,1,1,1]的所有组组合的最简单方法是将组1至21加载为组A,然后将A后的所有组加载为组B,将B后的所有组加载为组C,将B后的所有组加载为组C,将C后的所有组加载为组D,将D后的所有组加载为组E

 A  B  C  D  E
 1  2  3  4  5    <- ABCDE
 1  2  3  4  6    <- ABCDE
...
 1  2  3  4 25    <- ABCDE
 1  2  3  5  6    <- ABCDE
...
 1  2  3 24 25    <- ABCDE
 1  2  4  5  6    <- ABCDE
...
 1  2 23 24 25    <- ABCDE
 1  3  4  5  6    <- ABCDE
...
 1 22 23 24 25    <- ABCDE
 2  3  4  5  6    <- ABCDE
...
21 22 23 24 25    <- ABCDE
按零件数量对排列进行排序,例如:

k:   [1,1,1 ... 1]
k-1: [2,1 ... 1] [1,2 ... 1] ... [1,1 ... 2]
...
2:   [g,k-g] [k-g,g]
p=k-1: ABCDE [2,1,1,1,1] -> [a,a,b,c,d,e]    C(g,2)*C(g,1)^4 combinations
             [1,2,1,1,1] -> [a,b,b,c,d,e]
             [1,1,2,1,1] -> [a,b,c,c,d,e]
             [1,1,1,2,1] -> [a,b,c,d,d,e]
             [1,1,1,1,2] -> [a,b,c,d,e,e]
       ABCDE [2,1,1,1,1] -> [a,a,b,c,d,f]
             [1,2,1,1,1] -> [a,b,b,c,d,f]
             [1,1,2,1,1] -> [a,b,c,c,d,f]
             [1,1,1,2,1] -> [a,b,c,d,d,f]
             [1,1,1,1,2] -> [a,b,c,d,f,f]
       ...
       BCDEF [2,1,1,1,1] -> [b,b,c,d,e,f]
             [1,2,1,1,1] -> [b,c,c,d,e,f]
             [1,1,2,1,1] -> [b,c,d,d,e,f]
             [1,1,1,2,1] -> [b,c,d,e,e,f]
             [1,1,1,1,2] -> [b,c,d,e,f,f]
将前k个组加载到内存中,例如:

A  B  C  D  E  F
1  2  3  4  5  6
对于分区p的每个长度,生成大小为p的每组,例如:

对于这些集合中的每一个,生成具有相应数量部件的分区组合,例如:

k:   [1,1,1 ... 1]
k-1: [2,1 ... 1] [1,2 ... 1] ... [1,1 ... 2]
...
2:   [g,k-g] [k-g,g]
p=k-1: ABCDE [2,1,1,1,1] -> [a,a,b,c,d,e]    C(g,2)*C(g,1)^4 combinations
             [1,2,1,1,1] -> [a,b,b,c,d,e]
             [1,1,2,1,1] -> [a,b,c,c,d,e]
             [1,1,1,2,1] -> [a,b,c,d,d,e]
             [1,1,1,1,2] -> [a,b,c,d,e,e]
       ABCDE [2,1,1,1,1] -> [a,a,b,c,d,f]
             [1,2,1,1,1] -> [a,b,b,c,d,f]
             [1,1,2,1,1] -> [a,b,c,c,d,f]
             [1,1,1,2,1] -> [a,b,c,d,d,f]
             [1,1,1,1,2] -> [a,b,c,d,f,f]
       ...
       BCDEF [2,1,1,1,1] -> [b,b,c,d,e,f]
             [1,2,1,1,1] -> [b,c,c,d,e,f]
             [1,1,2,1,1] -> [b,c,d,d,e,f]
             [1,1,1,2,1] -> [b,c,d,e,e,f]
             [1,1,1,1,2] -> [b,c,d,e,f,f]
从集合列表中,删除不包含最后一组(F)的集合:

将下一组(最多为e/g)作为组F加载到内存中,例如:

A  B  C  D  E  F
1  2  3  4  5  7
...
1  2  3  4  5 e/g
A    B    C    D    E    F
1    2    3    4    6    7
...
1    2    3    4  e/g-1 e/g
A     B     C     D     E     F
1     2     3     5     6     7
...
1     2     3   e/g-2 e/g-1  e/g
同样,对于其中的每一个,以及每一个集合,生成具有相应数量的部分的分区组合

从名单上
A  B  C  D  E  F
1  2  3  4  5  7
...
1  2  3  4  5 e/g
p=k:   ABCDEF
p=k-1: ABCEF ABDEF ACDEF BCDEF
p=k-2: ABEF ACEF ADEF BCEF BDEF CDEF
...
p=2:   EF
A    B    C    D    E    F
1    2    3    4    6    7
...
1    2    3    4  e/g-1 e/g
p=k:   ABCDEF
p=k-1: ABDEF ACDEF BCDEF
p=k-2: ADEF BDEF CDEF
...
p=2:   none
A     B     C     D     E     F
1     2     3     5     6     7
...
1     2     3   e/g-2 e/g-1  e/g
  A     B     C     D     E     F
e/g-5 e/g-4 e/g-3 e/g-2 e/g-1  e/g
p=k:   ABCDEF
number of groups in memory: 3 (k)  
group size: g = m/k = 3 elements  
number of groups: e/g = 7  
groups: 1:[1,2,3] 2:[4,5,6] 3:[7,8,9] 4:[10,11,12] 5:[13,14,15] 6:[16,17,18] 7:[19,20,21]  
number of element sets loaded into memory: C(e/g,k) = C(7,3) = 35  
partitions of k with max part g: [1,1,1] [2,1] [3]  
permutations: 3:{[1,1,1]} 2:{[1,2],[2,1]} 1:{[3]}  
group sets: 3:{[A,B,C]} 2:{[A,B],[A,C],[B,C]} 1:{[A],[B],[C]}  
group sets: 3:{[A,B,C]} 2:{[A,B],[A,C],[B,C]} 1:{[A],[B],[C]}  (all)

A B C
1 2 3 -> elements in memory: [1,2,3] [4,5,6] [7,8,9] -> 84 combinations

3: [1,1,1]:[A,B,C] -> [a,b,c] -> [1,4,7] [1,4,8] [1,4,9] [1,5,7] [1,5,8] [1,5,9] [1,6,7] [1,6,8] [1,6,9]
                                 [2,4,7] [2,4,8] [2,4,9] [2,5,7] [2,5,8] [2,5,9] [2,6,7] [2,6,8] [2,6,9]
                                 [3,4,7] [3,4,8] [3,4,9] [3,5,7] [3,5,8] [3,5,9] [3,6,7] [3,6,8] [3,6,9]

2: [1,2]:[A,B] -> [a,b,b] -> [1,4,5] [1,4,6] [1,5,6] [2,4,5] [2,4,6] [2,5,6] [3,4,5] [3,4,6] [3,5,6]
   [1,2]:[A,C] -> [a,c,c] -> [1,7,8] [1,7,9] [1,8,9] [2,7,8] [2,7,9] [2,8,9] [3,7,8] [3,7,9] [3,8,9]
   [1,2]:[B,C] -> [b,c,c] -> [4,7,8] [4,7,9] [4,8,9] [5,7,8] [5,7,9] [5,8,9] [6,7,8] [6,7,9] [6,8,9]
   [2,1]:[A,B] -> [a,a,b] -> [1,2,4] [1,3,4] [2,3,4] [1,2,5] [1,3,5] [2,3,5] [1,2,6] [1,3,6] [2,3,6]
   [2,1]:[A,C] -> [a,a,c] -> [1,2,7] [1,3,7] [2,3,7] [1,2,8] [1,3,8] [2,3,8] [1,2,9] [1,3,9] [2,3,9]
   [2,1]:[B,C] -> [b,b,c] -> [4,5,7] [4,6,7] [5,6,7] [4,5,8] [4,6,8] [5,6,8] [4,5,9] [4,6,9] [5,6,9]

1: [3]:[A] -> [a,a,a] -> [1,2,3]
   [3]:[B] -> [b,b,b] -> [4,5,6]
   [3]:[C] -> [c,c,c] -> [7,8,9]
group sets: 3:{[A,B,C]} 2:{[A,C],[B,C]} 1:{[C]}  (sets without C removed)

A B C
1 2 4 -> elements in memory: [1,2,3] [4,5,6] [10,11,12] -> 64 combinations

3: [1,1,1]:[A,B,C] -> [a,b,c] -> [1,4,10] [1,4,11] [1,4,12] [1,5,10] [1,5,11] [1,5,12] [1,6,10] [1,6,11] [1,6,12]
                                 [2,4,10] [2,4,11] [2,4,12] [2,5,10] [2,5,11] [2,5,12] [2,6,10] [2,6,11] [2,6,12]
                                 [3,4,10] [3,4,11] [3,4,12] [3,5,10] [3,5,11] [3,5,12] [3,6,10] [3,6,11] [3,6,12]

2: [1,2]:[A,C] -> [a,c,c] -> [1,10,11] [1,10,12] [1,11,12] [2,10,11] [2,10,12] [2,11,12] [3,10,11] [3,10,12] [3,11,12]
   [1,2]:[B,C] -> [b,c,c] -> [4,10,11] [4,10,12] [4,11,12] [5,10,11] [5,10,12] [5,11,12] [6,10,11] [6,10,12] [6,11,12]
   [2,1]:[A,C] -> [a,a,c] -> [1,2,10] [1,3,10] [2,3,10] [1,2,11] [1,3,11] [2,3,11] [1,2,12] [1,3,12] [2,3,12]
   [2,1]:[B,C] -> [b,b,c] -> [4,5,10] [4,6,10] [5,6,10] [4,5,11] [4,6,11] [5,6,11] [4,5,12] [4,6,12] [5,6,12]

1: [3]:[C] -> [c,c,c] -> [10,11,12]

A B C
1 2 5 -> elements in memory: [1,2,3] [4,5,6] [13,14,15] -> 64 combinations
1 2 6 -> elements in memory: [1,2,3] [4,5,6] [16,17,18] -> 64 combinations
1 2 7 -> elements in memory: [1,2,3] [4,5,6] [19,20,21] -> 64 combinations
group sets: 3:{[A,B,C]} 2:{[B,C]}  (sets without B removed)

A B C
1 3 4 -> elements in memory: [1,2,3] [7,8,9] [10,11,12] -> 45 combinations

3: [1,1,1]:[A,B,C] -> [a,b,c] -> [1,7,10] [1,7,11] [1,7,12] [1,8,10] [1,8,11] [1,8,12] [1,9,10] [1,9,11] [1,9,12]
                                 [2,7,10] [2,7,11] [2,7,12] [2,8,10] [2,8,11] [2,8,12] [2,9,10] [2,9,11] [2,9,12]
                                 [3,7,10] [3,7,11] [3,7,12] [3,8,10] [3,8,11] [3,8,12] [3,9,10] [3,9,11] [3,9,12]

2: [1,2]:[B,C] -> [b,c,c] -> [7,10,11] [7,10,12] [7,11,12] [8,10,11] [8,10,12] [8,11,12] [9,10,11] [9,10,12] [9,11,12]
   [2,1]:[B,C] -> [b,b,c] -> [7,8,10] [7,9,10] [8,9,10] [7,8,11] [7,9,11] [8,9,11] [7,8,12] [7,9,12] [8,9,12]

A B C
1 3 5 -> elements in memory: [1,2,3] [7,8,9] [13,14,15] -> 45 combinations
1 3 6 -> elements in memory: [1,2,3] [7,8,9] [16,17,18] -> 45 combinations
1 3 7 -> elements in memory: [1,2,3] [7,8,9] [19,20,21] -> 45 combinations
1 4 5 -> elements in memory: [1,2,3] [7,8,9] [13,14,15] -> 45 combinations
1 4 6 -> elements in memory: [1,2,3] [7,8,9] [16,17,18] -> 45 combinations
1 4 7 -> elements in memory: [1,2,3] [7,8,9] [19,20,21] -> 45 combinations
1 5 6 -> elements in memory: [1,2,3] [7,8,9] [16,17,18] -> 45 combinations
1 5 7 -> elements in memory: [1,2,3] [7,8,9] [19,20,21] -> 45 combinations
1 6 7 -> elements in memory: [1,2,3] [7,8,9] [19,20,21] -> 45 combinations
group sets: 3:{[A,B,C]}  (sets without A removed)

A B C
2 3 4 -> elements in memory: [4,5,6] [7,8,9] [10,11,12]       -> 27 combinations

3: [1,1,1]:[A,B,C] -> [a,b,c] -> [4,7,10] [4,7,11] [4,7,12] [4,8,10] [4,8,11] [4,8,12] [4,9,10] [4,9,11] [4,9,12]
                                 [5,7,10] [5,7,11] [5,7,12] [5,8,10] [5,8,11] [5,8,12] [5,9,10] [5,9,11] [5,9,12]
                                 [6,7,10] [6,7,11] [6,7,12] [6,8,10] [6,8,11] [6,8,12] [6,9,10] [6,9,11] [6,9,12]

A B C
2 3 5 -> elements in memory: [4,5,6] [7,8,9] [13,14,15]       -> 27 combinations
2 3 6 -> elements in memory: [4,5,6] [7,8,9] [16,17,18]       -> 27 combinations
2 3 7 -> elements in memory: [4,5,6] [7,8,9] [19,20,21]       -> 27 combinations
2 4 5 -> elements in memory: [4,5,6] [10,11,12] [13,14,15]    -> 27 combinations
2 4 6 -> elements in memory: [4,5,6] [10,11,12] [16,17,18]    -> 27 combinations
2 4 7 -> elements in memory: [4,5,6] [10,11,12] [19,20,21]    -> 27 combinations
2 5 6 -> elements in memory: [4,5,6] [13,14,15] [16,17,18]    -> 27 combinations
2 5 7 -> elements in memory: [4,5,6] [13,14,15] [19,20,21]    -> 27 combinations
2 6 7 -> elements in memory: [4,5,6] [16,17,18] [19,20,21]    -> 27 combinations
3 4 5 -> elements in memory: [7,8,9] [10,11,12] [13,14,15]    -> 27 combinations
3 4 6 -> elements in memory: [7,8,9] [10,11,12] [16,17,18]    -> 27 combinations
3 4 7 -> elements in memory: [7,8,9] [10,11,12] [19,20,21]    -> 27 combinations
3 5 6 -> elements in memory: [7,8,9] [13,14,15] [16,17,18]    -> 27 combinations
3 5 7 -> elements in memory: [7,8,9] [13,14,15] [19,20,21]    -> 27 combinations
3 6 7 -> elements in memory: [7,8,9] [16,17,18] [19,20,21]    -> 27 combinations
4 5 6 -> elements in memory: [10,11,12] [13,14,15] [16,17,18] -> 27 combinations
4 5 7 -> elements in memory: [10,11,12] [13,14,15] [19,20,21] -> 27 combinations
4 6 7 -> elements in memory: [10,11,12] [16,17,18] [19,20,21] -> 27 combinations
5 6 7 -> elements in memory: [13,14,15] [16,17,18] [19,20,21] -> 27 combinations
Phase 1:      84 =   84 combinations
Phase 2:  4 x 64 =  256 combinations
Phase 3: 10 x 45 =  450 combinations
Phase 4: 20 x 27 =  540 combinations
                   ----
                   1330 combinations = C(21,3)