关于c ++：在无序元素上有效唯一

Effective unique on unordered elements

我想提高我在分形分析中使用的盒计数方法的速度性能。

关于任务

我有一个整数流(大约n=2^24长)，我必须计算流中有多少不同的值。没有上限，允许负值(但负值的数量可能小于sqrt(n))。流中存在一个小的相关性，即实际元素可能等于或不太远。在很多情况下，我在整个范围内有很多相同的值。

我已经尝试过的方法向量，排序，uniqe

STD：：St::排序，然后STD：：唯一的。

这个方法的复杂度是O(n*log(n))，我认为在缩放方面，其他任何算法一般都不会更快。但我相信一定存在一个比这更快的代码，但具有相同的缩放属性——只有在使用常量因子时才会更快。原因是：

我在向量中存储了很多相等的值，所以排序没有那么有效，向量太大了

在这个方法中，我不使用实际元素和前一个元素彼此接近的信息

我不需要关于这些唯一值是什么的信息，我只需要不同元素的数量

设置、插入、大小

为了消除第一个无效点，我使用set：：insert将每个元素放入一个集合中。最后，我计算了set:：size的元素数。

我的期望是，这段代码必须更快，因为集合中只存储唯一的值，而且不需要将新元素与大量相等的值进行比较。但不幸的是，这种方法比前一种方法慢了1.5倍。

set，emplace_提示，大小

为了消除第二个无效性点，我不仅将每个元素放入一个集合中，而且使用函数set：：emplace_提示。每次a提示将新元素放在前一个元素旁边。最后，我问了集合的大小和集合：：大小

我的期望是，这段代码必须比前一段代码更快，因为我可以猜出新元素的值，它比什么都没有要好。但不幸的是，这种方法比前一种方法慢5倍。

问题

你能建议任何有效的方法来计算流中不同元素(ints)的数量吗？如果知道的话，你能优化代码吗？

数字之间有可测量的相关性。

有些数字是重复出现的

目标体系结构是现代x86或x86-64 PC处理器(带有SSE、SSE2)，只有单线程代码才适用。我不喜欢使用Boost而是C++ 11。

解决方案

首先，感谢您的建议、耐心和理解，很抱歉我无法测试所有方法，而且我也确信有效性取决于我没有提供的Int流的细节。不过，我将与VS2013编译器共享我得到的结果。(代码是在GCC4.7下测试的，但没有经过测量。)这个主题值得花更多的时间来研究，但我有一个适合我需要的解决方案。 Time statistics for different methods 。

关于方法：

bool向量：Dieter l_cking的位向量解
二进制查找：Tony D建议的方法
无序集合：将所有元素简单地放入STD：：unOrdEdset，然后根据IxaNeZIS提出其元素的数量
向量插入排序：使用Dieter L护cking的排序向量方法
集合插入：我在问题表单中描述的方法
基排序：Ixanezis的建议，使用一种流行的向量排序算法
设置EnPosits提示：使用STD：：EMPTHORY提示，如问题表中所描述的

相关讨论

由于您只处理有限范围的整数，因此可以在这里有效地使用基数排序算法，从而减少log(N)部分的复杂性。您可以在Internet的某个地方选择任何真正快速的实现。其中一些需要SSE支持，另一些需要多线程，甚至需要在GPU上运行。

如果您有可能使用boost::unordered_set或C++11std::unordered_set，那么您的第二种方法可以很容易地修改您使用的方法，也会导致线性复杂度算法。但是，如果流中至少有几百万个数字，我相信第一种方法会更快。

相关讨论

只是比较不同的方法(不考虑基数排序)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200

#include
#include <deque>
#include <iostream>
#include <unordered_set>
#include <set>
#include <vector>
#include <chrono>

template <template <typename ...> class Container, typename T, typename ... A, typename Comp>
inline bool insert_sorted(Container<T, A...>& container, T const& e, Comp const& comp) {
auto const it = std::lower_bound(container.begin(), container.end(), e, comp);
if (it != container.end() and not comp(e, *it)) { return false; }
container.insert(it, e);
return true;
}

template <template <typename ...> class Container, typename T, typename ... A>
inline bool insert_sorted(Container<T, A...>& container, T const& e) {
return insert_sorted(container, e, std::less<T>{});
}

int main() {
using namespace std::chrono;
typedef std::vector<int> data_type;

const unsigned Size = unsigned(1) << 24;
const unsigned Limit = 1000;
data_type data;
data.reserve(Size);
for(unsigned i = 0; i < Size; ++i) {
int value = double(Limit) * std::rand() / RAND_MAX - 0.1;
data.push_back(value);
while(i < Size - 1 && rand() < RAND_MAX * 0.25) {
data.push_back(value);
++i;
}
}

std::cout
<<"Data
"
<<"====
"
<<" Size of data:" << Size << '
';

std::cout
<<"Unorderd Set
"
<<"============
";
{
auto start = system_clock::now();

typedef std::unordered_set<int> set_type;
set_type set;
unsigned i = 0;
for( ; i < Size - 1; ++i) {
// Ignore a range of equal values
while(data[i] == data[i+1]) ++i;
set.insert(data[i]);
}
if(i < Size)
set.insert(data[i]);

auto stop = system_clock::now();

std::cout
<<"Number of different elements:"
<< set.size() << '
';
std::cout
<<" Timing:"
<< duration_cast<duration<double>>(stop - start).count()
<< '
';
}

std::cout
<<"Set
"
<<"===
";
{
auto start = system_clock::now();

typedef std::set<int> set_type;
set_type set;
unsigned i = 0;
for( ; i < Size - 1; ++i) {
// Ignore a range of equal values
while(data[i] == data[i+1]) ++i;
set.insert(data[i]);
}
if(i < Size)
set.insert(data[i]);

auto stop = system_clock::now();

std::cout
<<"Number of different elements:"
<< set.size() << '
';
std::cout
<<" Timing:"
<< duration_cast<duration<double>>(stop - start).count()
<< '
';
}

std::cout
<<"Sorted Vector
"
<<"=============
";
{
auto start = system_clock::now();

typedef std::vector<int> set_type;
set_type set;
unsigned i = 0;
for( ; i < Size - 1; ++i) {
// Ignore a range of equal values
while(data[i] == data[i+1]) ++i;
insert_sorted(set, data[i]);
}
if(i < Size)
insert_sorted(set, data[i]);

auto stop = system_clock::now();

std::cout
<<"Number of different elements:"
<< set.size() << '
';
std::cout
<<" Timing:"
<< duration_cast<duration<double>>(stop - start).count()
<< '
';
}

std::cout
<<"BitVector
"
<<"=========
";
{
auto start = system_clock::now();

typedef std::vector<bool> set_type;
set_type set(Limit);
unsigned i = 0;
unsigned elements = 0;
for( ; i < Size; ++i) {
if( ! set[data[i]]) {
set[data[i]] = true;
++elements;
}
}

auto stop = system_clock::now();

std::cout
<<"Number of different elements:"
<< elements << '
';
std::cout
<<" Timing:"
<< duration_cast<duration<double>>(stop - start).count()
<< '
';
}

std::cout
<<"Sorted Data
"
<<"===========
";
{
auto start = system_clock::now();

std::sort(data.begin(), data.end());
auto last = std::unique(data.begin(), data.end());

auto stop = system_clock::now();

std::cout
<<"Number of different elements:"
<< last - data.begin() << '
';
std::cout
<<" Timing:"
<< duration_cast<duration<double>>(stop - start).count()
<< '
';
}

return 0;
}

用G++STD＝C++＋11—O3编译：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Data
====
Size of data: 16777216
Unorderd Set
============
Number of different elements: 1000
Timing: 0.269752
Set
===
Number of different elements: 1000
Timing: 1.23478
Sorted Vector
=============
Number of different elements: 1000
Timing: 1.13783
BitVector
=========
Number of different elements: 1000
Timing: 0.038408
Sorted Data
===========
Number of different elements: 1000
Timing: 1.32827

。

因此，如果内存没有问题，或者数字的范围有限，那么设置一个位是最好的选择。否则，无序集是一个很好的集。

相关讨论

假设32位int，最坏的情况是需要2^32位来跟踪可能看到的每个数字的已看到/未看到状态。这是40亿位，也就是5.12亿字节——5.12兆字节——对于现代台式电脑来说，这并不是什么禁忌。您基本上可以将一个字节[n/8]索引到数组中，然后使用1 << (n % 8)按位和或或来设置或测试数字的可见状态。因为您说输入中接近的数字在值上趋向于接近，所以缓存利用率应该相当好。您可以检查刚才看到的数字并绕过位数组处理。

如果您碰巧知道在输入中要跟踪的不同数字少于2^32，那么您当然应该相应地减小位集的大小。(只需阅读您的评论"允许使用负数，但非常罕见(可能性小于1/n)。"—在这种情况下，您可以使用set表示负数，使用一半的内存表示正数)。

(如果您担心在许多内存页上进行最后一次迭代，而这些内存页可能根本没有设置任何位，那么您可以创建一个额外的"脏页"索引(每页一位)来指导这种迭代，但是给定输入的数量，如果该输入在int的数值范围内广泛分布，则可能是无关紧要的，甚至是适得其反的。)

按注释要求编辑/进一步解释。第一，实施：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

template <size_t N>
class Tracker
{
public:
Tracker() { std::fill_n(&data_[0], words, 0); }
void set(int n) { data_[n / 32] |= (1u << (n % 8)); }
bool test(int n) const { return data_[n / 32] &= (1u << (n % 8)); }

template <typename Visitor>
void visit(Visitor& visitor)
{
for (size_t word = 0, word_n = 0; word < words; ++word, word_n += 32)
if (data_[word])
for (uint32_t n = 0, value = 1; n < 32; ++n, value *= 2)
if (data_[word] & value)
visitor(word_n + n);
}
private:
static const int words = N / 32 + (N % 32 ? 1 : 0);
uint32_t data_[words];
};

用途：

1
2
3
4
5
6

Tracker<size_t(std::numeric_limits<int>::max()) + 1> my_tracker;
int n;
while (std::cin >> n)
my_tracker.set(n);
my_tracker.visit([](unsigned n) { std::cout << n << '
'; });

号

(未测试…可能有一些小问题)

Can you explain your answer more detailed please?

号

所有这一切都是创建一个概念上只是一个bool have_seen[]数组，它可以被您感兴趣的任何整数直接索引：您只需通过输入将在输入中看到的索引处的布尔元素设置为true。如果你两次或两次以上把某件事变成现实，谁在乎呢？纯粹是为了节省内存并加快搜索设定位的速度(例如，填充/清除)，它是手动将bool值打包成更大整数数据类型的位。

I think I can bother with negative values because I can calculate the largest and smallest values for a total cost of O(n).

号

嗯，也许吧，但是两次传球可能更快或更慢。根据我记录的方法，您不需要检查数据两次…您可以在第一次迭代期间准备答案。当然，如果进行初始迭代很快(例如从SSD媒体)，并且您的内存足够紧，以至于只需要对实际数据范围进行实际分析，那么就开始执行。

It also facilitates to shrink the width of the int into the correct value, so more than half of the pages will be non-empty.

号

不知道你的意思。

相关讨论

好方法，还有STD：：BITSET，很容易实现。但是，如果您需要多次解决该任务，则必须跟踪上次设置为1的位，以便能够在下次启动前"清理"它们。如果数据集只包含关于2^24元素，那么简单的memset可能不是一个好主意。以及+1，用于实际应用corellation输入。
@Ixanezis谢谢：—)。我几乎提到了bitset，但是afaik它缺乏在处理结束时高效地报告设置位的能力(称为.test(n))看起来很糟糕，特别是在长时间运行0的情况下。对于一个快速的clear()，脏页的想法可能是值得的——允许目标memset——如果页面上有任何位，那么缓存故障可能是瓶颈。但是，证据总是在基准测试中…直到系统或数据发生变化。-)
你能详细解释一下你的答案吗？我想我可以考虑负值，因为我可以计算出O(N)总成本的最大值和最小值。它还便于将int的宽度缩小到正确的值，因此超过一半的页面将是非空的。
@Danieltuzes-添加了更多解释/代码。
我在这里以std::deque为基础进行了尝试；我可能犯了一个错误…如果我不认为这个方法是不切实际的(它超时了，而页面上显示的其他3个方法都有时间执行)。恐怕除了内存量(这在任何计算机上都是微不足道的)，这是由缓存未命中造成的。
@马蒂厄姆。我只看了60秒，但你不是在看随机数吗？这对于缓存来说是最糟糕的，与Daniel声明的输入的分组和重复输入的特性非常不同。所以，在这个阶段，我不会调查您是否还有其他的实现问题。干杯。
@托尼德：我读过这个问题的操作说明，不幸的是，它非常不精确。例如，没有比率：100个唯一数字或2*16个唯一数字的最佳解决方案可能非常不同！尽管如此，他并没有给两个连续的价值观彼此接近的机会，所以又一次走到了死胡同。如果不进一步描述这个问题，一个随机的样本就和我能得到的一样精确：x
@托尼德：现在我明白你的建议了，我不说"缩小int的宽度"。但是现在我认为这个解决方案可以有类似于Dieter L&252；cking描述的"位向量"(一个向量)的性能。我也会很快测试你的解决方案。
"danieltuzes比特的设置是有效的std::vector或std::bitset<>样A，但这些也有一个机制，只是后来被设置位(样的"访问"上面的代码)。马修的基准"脏页让我觉得我可以说"思想价值实现——基本上是有一个说的bitset<>均值(4K位可能通过内存页)，如果这是不是在所有集合的迭代4096位在更大的值可以忽略，faulting回页面上缓存。效益/成本的比例取决于肮脏的页面)。
而不是使用n & 7n % 8呢？它可以是更快，同样的价值为n = 0。value << 1value *= 2和同样的，不是吗？
编译器的优化danieltuzes"你知道我；-)。无论你使用的明确，和开关使用时应该是什么。
我不是说size_t(std::numeric_limits::max()) + 1编译器的编译时常数表达。所以我-2147483648取代它。该函数用于在bool test(int n) const不是代码，是它的目的？他们是&=A大学&代替这功能吗？为什么在compilacted void visit(Visitor& visitor)模板？我的意思是它是漂亮的，但一个简单的计数器将是不够的。无论如何，unfortunatelly堆栈溢出程序，然后访问冲突时，它提供的功能是在Tracker<2147483648> my_tracker;。
"它可能更容易danieltuzes跟踪器是一个没有解决的模板，和数组大小恒定，可以修复自己的堆栈溢出，如果需要，创建一个新的跟踪器的一堆。测试是一种很有帮助班上的一位documenting和更完整的自我。它应该只是个&；。如果你只想使用计数类mattieu精细编码的思想，这是你的价值一般的湖泊。
一个纠正代码。所以我删除的大小和堆栈溢出了安切洛蒂的模板参数。在一个错误的% 8void set(int n)可以给它洗澡，但% 32似乎效果良好。为小数据，本方法通过将一位比最快的布尔向量>与<在实时检查(AS的书面由Dieter L和# 252；cking)或后计数。
我想为你关心的实际数据值，检查你集A位似乎没有有用的，但如果你想你可以修改你的计数，然后在我的答案的代码位设置应检查它的速度在这里。如果你想让这甚至更快，你可以尝试使用x86指令这一BTS的测算值设置位，和3位在一个旧的价值。如果页面缓存是瓶颈，它不会帮助，否则它可能会。

将当前元素与前一个元素进行比较，然后将其传递给计数方法(不管它是什么)，会有帮助吗？

还是保留一个小的/快速的缓存，比如最后10个元素，以丢弃短范围重复？

还是分批计数(用临时计数器按100的顺序计数，然后与以前的计数合并)？

相关讨论

此任务的标准数据结构是散列集，在stl中称为std::unordered_set(btw，Google的密集散列集通常性能稍好一些)

您不需要对唯一的值进行排序，因此对于您的用例来说，std::set的速度是不确定的。

像其他人建议的那样，如果你的宇宙(可能的值)不太大，你也可以使用位向量。如果你有负值，你可以直接转换成无符号，然后把它们当作真正的大数字。

我同意尝试使用stl容器(set、unordered_set…)，但不幸的是，您要为它们付出代价：它们的内存稳定性和轻量级迭代器需求要求它们作为基于节点的容器来实现，并且每个元素都有很大(相对而言)开销。

我建议采用两种方法：

坚持使用vector(仅在独特物品比例较低的情况下有效)

实现罗宾汉哈希

使用概率方法

排序向量

对于vector方法：没有什么可以阻止您在插入时对vector进行排序，从而避免插入重复的元素。这里有一个例子：

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

#include <iostream>

#include
#include <vector>

template <typename T, typename Comp>
void insert_sorted(std::vector<T>& vec, T const& e, Comp const& comp) {
auto const it = std::lower_bound(vec.begin(), vec.end(), e, comp);

if (it != vec.end() and not comp(e, *it)) { return; }

vec.insert(it, e);
}

template <typename T>
void insert_sorted(std::vector<T>& vec, T const& e) {
insert_sorted(vec, e, std::less<T>{});
}

int main() {
int const array[] = { 4, 3, 6, 2, 3, 6, 8, 4 };

std::vector<int> vec;
for (int a: array) {
insert_sorted(vec, a);
}

std::cout << vec.size() <<":";
for (int a: vec) { std::cout <<"" << a; }
std::cout <<"
";

return 0;
}

显示：5: 2 3 4 6 8。

显然，这仍然是O(n log n)，但是它需要更少的内存：

内存越少，缓存中的向量就越多
前一个接近其后继元素的元素被lower_bound的二进制搜索所利用，该搜索通过几乎相同的缓存线。

这应该已经是一个很大的进步了。

注：已经指出，在向量中间插入是无效的。当然，因为它涉及到改变现有元素的一半(平均)。不过基准测试表明，当唯一元素的数量很小时(0.1%是我的基准)，它可以击败当前的vector解决方案。

罗宾汉·哈辛

更多的参与，但罗宾汉散列有很好的特点，因此性能。最值得注意的是，它是在单个动态数组(如vector)之上实现的，因此显示出良好的内存位置。

Rust将哈希表的默认实现改为Robin Hood哈希，并对此非常满意。

注：从快速基准来看，即使是unordered_set也比不上商店和商店，一个简单的开放地址哈希表也快25%。

概率方法

对于非常大的问题，一个非常著名的算法是hyperloglog。最近在Redis中实现了。

它具有很好的内存使用率与错误率之比，并且实现起来相对简单(尤其是遵循Antirez的代码)。

在这个问题上投入更多的硬件

请注意，这是一个令人尴尬的并行问题，因此您可以轻松地拥有多个线程：

从流中选择一束ID(例如：2**10一次)
将它们合并为一组线程本地唯一ID(无论其实现如何)
循环直到流为空
最后将结果合并在一起

你可以得到一个接近线程数量的加速(显然有一些开销)。

注意：这两种方法可以很容易地适应这种方法，这两种方法都支持有效的合并。

相关讨论

我希望你在开玩笑。插入到向量的中间需要变换元素，它显然具有线性复杂性，从而导致总体O(n*n*log(n))复杂性。除非数据集中只有很少的不同元素，否则这个算法似乎是最糟糕的。或者我错过了什么……
这是O(n^2)，不是O(n log n)，因为每次插入都有一系列动作。您描述的算法基本上是二进制插入排序。
@Avidanborisov不，它有O(n^2 * log n)，因为增加了lower_bound。
不，它是O(n(n + log n))，渐近等价于O(n^2)。
我同意Ixanezis的观点，即在向量中间插入元素是不有效的。但概率方法仍然是不可接受的。我有一个分形，这是很难估计的误差，我不能使用结果，如果它有伪影。给出了硬件，但问题不在于如何并行代码，更大的计算能力与代码效率无关。不管怎样，谢谢你的回复，我很感激！
@是的，你是对的，我错了。无法修复我的第一条评论，很遗憾：(
@不，我是认真的。我们在这里处理两个数字：n是读取的项目数，u是读取的唯一项目数。vector解决方案只在U方面发展，而不是在N方面发展，因此它明显倾向于U << N的情况。尽管如此，即使当U接近N时，由于内存效率和位置的原因，它可能比set插入更有效；让我们记住，int的移动降低到大的memcpy时，就不会一次移动一个。因此，在拍摄此解决方案之前，我将推荐一个基准。
@丹尼尔图兹：我在这里为你做了代码基准。虽然插入排序方法并不总是效率更高，但在Uunordered_set更高效(内存更少，指针间接寻址更少)。
我相信向量插入并不是一般的最优算法，但值得一试。我也试试。
@丹尼尔图兹：哦，总的来说，它肯定不是最佳的；正如伊萨内兹所指出的，它实际上退化得相当严重。当U增大时，即使是一个简单的std::unordered_set也会很快绕着它转。如果您希望尝试更通用和更高效的方法，我相信开放寻址哈希表(例如那些使用Robin Hood哈希的表)是最好的选择；不幸的是，它们不是标准的，据我所知，甚至没有在Boost中实现，因此要找到一个具有适当许可证的良好实现是很困难的，而且要滚动自己的(DebuggeD和优化)成本高昂。
@丹妮尔图兹：这里有一个快速和肮脏的开放寻址哈希集，它的性能比std::unordered_set高25%。
谢谢Mat，我不会忽视你的代码。