集和向量。 在C ++中设置很快吗？

Question

Please read the question here - http://www.spoj.com/problems/MRECAMAN/

The question was to compute the recaman's sequence where, a(0) = 0 and, a(i) = a(i-1)-i if, a(i-1)-i > 0 and does not come into the sequence before else, a(i) = a(i-1) + i .

Now when I use vectors to store the sequence, and use the find function, the program times out. But when I use an array and a set to see if the element exists, it gets accepted (very fast). IS using set faster?

Here are the codes:

Vector implementation

vector <int> sequence;
sequence.push_back(0);
for (int i = 1; i <= 500000; i++)
{
    a = sequence[i - 1] - i;
    b = sequence[i - 1] + i;
    if (a > 0 && find(sequence.begin(), sequence.end(), a) == sequence.end())
        sequence.push_back(a);
    else
        sequence.push_back(b);
}

Set Implementation

int a[500001]
set <int> exists;
a[0] = 0;
for (int i = 1; i <= MAXN; ++i)
{
    if (a[i - 1] - i > 0 && exists.find(a[i - 1] - i) == exists.end()) a[i] = a[i - 1] - i;
    else a[i] = a[i - 1] + i;
    exists.insert(a[i]);
}

Answer 1

Lookup in an std::vector :

find(sequence.begin(), sequence.end(), a)==sequence.end()

is an O(n) operation ( n being the number of elements in the vector).

Lookup in an std::set (which is a balanced binary search tree):

exists.find(a[i-1] - i) == exists.end()

is an O(log n) operation.

So yes, lookup in a set is (asymptotically) faster than a linear lookup in vector .

Answer 2

For the task at hand, set is faster than vector because it keeps its contents sorted and does a binary search to find a specified item, giving logarithmic complexity instead of linear complexity. When the set is small, that difference is also small, but when the set gets large the difference grows considerably. I think you can improve things a bit more than just that though.

First, I'd avoid the clumsy lookup to see if an item is already present by just attempting to insert an item, then see if that succeeded:

    if (b>0 && exists.insert(b).second)
        a[i] = b;
    else {
        a[i] = c;
        exists.insert(c);
    }

This avoids looking up the same item twice, once to see if it was already present, and again to insert the item. It only does a second lookup when the first one was already present, so we're going to insert some other value.

Second, and even more importantly, you can use std::unordered_set to improve the complexity from logarithmic to (expected) constant. Since unordered_set uses (mostly) the same interface as std::set , this substitution is easy to make (including the optimization above.

Here's some code to compare the three methods:

#include <iostream>
#include <string>
#include <set>
#include <unordered_set>
#include <vector>
#include <numeric>
#include <chrono>

static const int MAXN = 500000;

unsigned original() {
    static int a[MAXN+1];
    std::set <int> exists;
    a[0] = 0;
    for (int i = 1; i <= MAXN; ++i)
    {
        if (a[i - 1] - i > 0 && exists.find(a[i - 1] - i) == exists.end()) a[i] = a[i - 1] - i;
        else a[i] = a[i - 1] + i;
        exists.insert(a[i]);
    }
    return std::accumulate(std::begin(a), std::end(a), 0U);
}

template <class container>
unsigned reduced_lookup() {
    container exists;
    std::vector<int> a(MAXN + 1);

    a[0] = 0;

    for (int i = 1; i <= MAXN; ++i) {
        int b = a[i - 1] - i;
        int c = a[i - 1] + i;

        if (b>0 && exists.insert(b).second)
            a[i] = b;
        else {
            a[i] = c;
            exists.insert(c);
        }
    }
    return std::accumulate(std::begin(a), std::end(a), 0U);

}

template <class F>
void timer(F f) {
    auto start = std::chrono::high_resolution_clock::now();
    std::cout << f() <<"\t";
    auto stop = std::chrono::high_resolution_clock::now();
    std::cout << "Time: " << std::chrono::duration_cast<std::chrono::milliseconds>(stop - start).count() << " ms\n";
}

int main() {
    timer(original);
    timer(reduced_lookup<std::set<int>>);
    timer(reduced_lookup<std::unordered_set<int>>);
}

Note how std::set and std::unordered_set provide similar enough interfaces that I've written the code as a single template that can use either type of container, then for timing just instantiated that for both set and unordered_set .

Anyway, here's some results from g++ (version 4.8.1, compiled with -O3):

212972756       Time: 137 ms
212972756       Time: 101 ms
212972756       Time: 63 ms

Changing the lookup strategy improves speed by about 30% ¹ and using unordered_set with the improved lookup strategy better than doubles the speed compared to the original--not bad, especially when the result actually looks cleaner, at least to me. You might not agree that it's cleaner looking, but I think we can at least agree that I didn't write code that was a lot longer or more complex to get the speed improvement.

---

_{1. Simplistic analysis indicates that it should be around 25%. Specifically, if we assume there are even odds of a given number being in the set already, then this eliminates half the lookups about half the time, or about 1/4 ^th of the lookups.}

Answer 3

There is only one valid answer to most "Is XY faster than UV in C++" questions:

Use a profiler.

While most algorithms (including container insertions, searches etc.) have a guaranteed complexity, these complexities can only tell you about the approximate behavior for large amounts of data. The performance for any given smaller set of data can not be easily compared, and the optimizations that a compiler can apply can not be reasonably guessed by humans. So use a profiler and see what is faster. If it matters at all. To see if performance matters in that special part of your program, use a profiler .

However, in your case it might be a safe bet that searching a set of ~250k elements can be faster than searching an unsorted vector of tat size. However, if you use the vector only for storing the inserted values and leave the sequence[i-1] out in a separate variable, you can keep the vector sorted and use an algorithm for sorted ranges like binary_search , which can be way faster than the set.

A sample implementation with a sorted vector:

const static size_t NMAX = 500000;
vector<int> values = {0};
values.reserve(NMAX );
int lastInserted = 0;

for (int i = 1; i <= NMAX) {
  auto a = lastInserted - i;
  auto b = lastInserted + i;

  auto iter = lower_bound(begin(values), end(values), a);
  //a is always less than the last inserted value, so iter can't be end(values)

  if (a > 0 && a < *iter) {
    lastInserted = a;
  }
  else {
    //b > a => lower_bound(b) >= lower_bound(a)
    iter = lower_bound(iter, end(values), b);
    lastInserted = b;
  }
  values.insert(iter, lastInserted);
}

I hope I did not introduce any bugs...

Answer 4

如果可以对向量进行排序，则在大多数情况下，查找比在集合中查找要快，因为它对缓存更友好。

Answer 5

The set is a huge speedup because it's faster to look up. (Btw, exists.count(a) == 0 is prettier than using find .)

That doesn't have anything to do with vector vs array though. Adding the set to the vector version should work just as fine.

Answer 6

It is classic space-time tradeoff. When you use only vector your program uses minimum memory but you should to find existing numbers on every step. It is slowly. When you use additional index data structure (like a set in your case) you dramatically speed up your code but your code now takes at least twice greater memory. More about tradeoff here .