Question

我想将内容转储到对象tmp_np中，这是一个UllmanSet，如果你知道一个键，那么你知道位置，如果你知道位置，你就知道了关键。是否有一个标准的C ++容器与Ullmanset类似。 Ullmanset的索引从0开始，Ullmanset1的索引从1开始。

并转储frontierq的内容，这是一个PriorityQ类。

UllmanSet tmp_np;

template<unsigned B>
class BasedUllmanSet
{
  size_t n;
  std::vector<int> key;
  BasedVector<unsigned, B> pos;

public:
  BasedUllmanSet()
    : n(0)
  {}
  BasedUllmanSet(size_t cap)
    : n(0), key(cap), pos(cap)
  {}

  size_t capacity() const { return key.size(); }
  size_t size() const { return n; }
  bool empty() const { return n == 0; }
  void clear() { n = 0; }
  void resize(size_t cap)
  {
    key.resize(cap);
    pos.resize(cap);
    n = 0;
  }

  bool contains(int k) const
  {
    unsigned p = pos[k];
    return (p < n
            && key[p] == k);
  }

  void insert(int k)
  {
    if (contains(k))
      return;

    unsigned p = n++;
    key[p] = k;
    pos[k] = p;
  }

  void extend(int k)
  {
    assert(!contains(k));

    unsigned p = n++;
    key[p] = k;
    pos[k] = p;
  }

  void erase(int k)
  {
    if (!contains(k))
      return;

    unsigned p = pos[k];
    --n;
    if (p != n)
      {
        int ell = key[n];
        pos[ell] = p;
        key[p] = ell;
      }
  }

  int ith(int i)
  {
    assert(i >= 0 && i < (int)n);
    return key[i];
  }
};

using UllmanSet = BasedUllmanSet<0>;
using UllmanSet1 = BasedUllmanSet<1>;





The priority queue is implemented as followed.  I like to print out the values inside the queue using std::cout. 




      PriorityQ<std::pair<int, int>, Comp> frontierq;

    class Comp
    {
    public:
      Comp() {}

      bool operator()(const std::pair<int, int> &lhs,
                      const std::pair<int, int> &rhs) const
      {
        return (lhs.second > rhs.second
                || (lhs.second == rhs.second
                    && lhs.first > rhs.first));
      }
    };

    class PriorityQ
    {
    public:
      Comp comp;
      std::vector<T> v;
      unsigned n;

    public:
      PriorityQ() : n(0) {}
      PriorityQ(Comp comp_) : comp(comp_), n(0) {}

      size_t size() const { return n; }
      void clear() { n = 0; }
      bool empty() { return n == 0; }

      void push(const T &x)
      {
        assert(v.size() >= n);
        if (v.size() == n)
          v.push_back(x);
        else
          v[n] = x;
        ++n;
        std::push_heap(&v[0], &v[n], comp);
      }
      const T &pop()
      {
        assert(n > 0);
        std::pop_heap(&v[0], &v[n], comp);
        --n;
        return v[n];
      }
      const T &top()
      {
        assert(n > 0);
        return v[0];
      }
    };

Answer 1

C ++标准容器确实让我们深思熟虑。如果您有关于优先级队列的其他问题，您应该另外发帖。

试图查看Ullmanset和优先级队列

1 个答案: