Question

以下是我的情景：

我必须保留扩展ASCII的所有3字节组合，如下所示：

{ { (a,a,a),(a,a,b),..........(z,z,z) } }

所有这些组合产生了一大组256 * 256 * 256值

在我的算法中，碰巧在每次迭代后，大集合都会出现这样的情况：

 {(a,a,a), (a,a,b)}
 {(a,a,c)}
.
.
.
.
{(z,z,z)}

我正在使用数组的向量来实现这个。

vector<set<array<char,3> > > Partition;

使用它的原因是一个大集将分解为子集。这些子集的数量是未知的，并且在每次迭代之后子集的数量可能增加，因此我使用向量。那么子集不应该包含任何元素两次，因此我使用set和数组来保存3个字符。

使用上述数据结构的问题在于计算结果需要花费大量时间。

我需要有关数据结构的建议，在我的情况下可以提高效率。

我的算法的更多解释：

{(a,a,a),(a,a,b)........ (z,z,z)}

所有这些三角板都是无序地图的关键。所有这些triplates都对应于像这样的某个值

(a,a,a)           value=2
(a,a,b)           value=2
(a,a,c)           value=3
(a,a,d)           value=2
.
.
.
.
.

现在，我运行我的算法并希望根据价值知道它们可以压缩多少：像这样

{(a,a,a) ,(a,a,b)  }          value=2
(a,a,c)                       value=3
{(a,a,d),......}              value=2

为什么我必须为value = 2创建一个单独的子集，因为根据我的算法，每当我的前一个值与当前值不同时，我必须创建一个新的集合。

Answer 1

你关心3 * 8b所以有24位值。您可以拥有{0, 0, 0}而不是0而不是{'a', 'a', 'a'}，而不是0x616161，因为'a' == 0x61

所有这些整数都可以存储在std::map中，其中由3个符号组成的整数是关键。或者您可以使用数组ValueType arr[256*256*256]。我建议使用数组，但是如果你只有几个值，你可以使用map。

要从int转换为3个字符，您可以使用按位操作<<和>>了解here和here。但我希望你能理解这一点。

Answer 2

为什么不只是一个阵列：

int[256*256*256] values;

创建一个联盟：

typedef struct
{
    byte b1;
    byte b2;
    byte b3;
} triplet;

union tIndex
{
    triplet trip;
    int index;
}

因此，如果您想访问项['a','b','c']，可以写：

union tIndex;
iIndex.index = 0;  // make sure all bytes are cleared.
tIndex.b1 = 'a';
tIndex.b2 = 'b';
tIndex.b3 = 'c';
values[tIndex.index] = 22;

因此，假设您使用值-1或其他在应用程序中无效的值初始化数组。然后运行修改某些数组项的计算。

然后，您可以按顺序浏览数组，挑选出具有相同计数的相邻项目，然后将它们组合在一起。

很难确定这是否有效，因为我没有很多关于你的应用程序的信息。但是，如果你能够这样想，它可以为你操纵向量和集合带来很多麻烦。