RhodeCode

      nodes[id].right = nodes[jd].prev;

    }

    void splice(int id, int jd) {

      nodes[id].size += nodes[jd].size;

      nodes[nodes[id].right].next = nodes[jd].left;

      nodes[nodes[jd].left].prev = nodes[id].right;

      int kd = nodes[jd].left;

      while (kd != -1) {

        nodes[kd].parent = id;

        kd = nodes[kd].next;

      }

      nodes[id].right = nodes[jd].right;

    }

    void split(int id, int jd) {

      int kd = nodes[id].parent;

      nodes[kd].right = nodes[id].prev;

      nodes[nodes[id].prev].next = -1;

      nodes[jd].left = id;

      nodes[id].prev = -1;

      int num = 0;

      while (id != -1) {

        nodes[id].parent = jd;

        nodes[jd].right = id;

        id = nodes[id].next;

        ++num;

      }

      nodes[kd].size -= num;

      nodes[jd].size = num;

    }

    void pushLeft(int id, int jd) {

      nodes[id].size += 1;

      nodes[jd].next = nodes[id].left;

      nodes[jd].prev = -1;

      nodes[nodes[id].left].prev = jd;

      nodes[id].left = jd;

      nodes[jd].parent = id;

    }

    void popLeft(int id) {

      nodes[id].size -= 1;

      int jd = nodes[id].left;

      nodes[nodes[jd].next].prev = -1;

      nodes[id].left = nodes[jd].next;

    }

    void repairLeft(int id) {

      int jd = ~(classes[id].parent);

      while (nodes[jd].left != -1) {

        int kd = nodes[jd].left;

        if (nodes[jd].size == 1) {

          if (nodes[jd].parent < 0) {

            classes[id].parent = ~kd;

            classes[id].depth -= 1;

            nodes[kd].parent = ~id;

            deleteNode(jd);

            jd = kd;

          } else {

            int pd = nodes[jd].parent;

            if (nodes[nodes[jd].next].size < cmax) {

              pushLeft(nodes[jd].next, nodes[jd].left);

              }

              popLeft(pd);

              deleteNode(jd);

              jd = pd;

            } else {

              int ld = nodes[nodes[jd].next].left;

              popLeft(nodes[jd].next);

              pushRight(jd, ld);

                nodes[jd].item = nodes[ld].item;

              }

              if (nodes[nodes[jd].next].item == nodes[ld].item) {

                setPrio(nodes[jd].next);

              }

              jd = nodes[jd].left;

            }

          }

        } else {

          jd = nodes[jd].left;

        }

      }

    }

    void repairRight(int id) {

      int jd = ~(classes[id].parent);

      while (nodes[jd].right != -1) {

        int kd = nodes[jd].right;

        if (nodes[jd].size == 1) {

          if (nodes[jd].parent < 0) {

            classes[id].parent = ~kd;

            classes[id].depth -= 1;

            nodes[kd].parent = ~id;

            deleteNode(jd);

            jd = kd;

          } else {

            int pd = nodes[jd].parent;

            if (nodes[nodes[jd].prev].size < cmax) {

              pushRight(nodes[jd].prev, nodes[jd].right);

              }

              popRight(pd);

              deleteNode(jd);

              jd = pd;

            } else {

              int ld = nodes[nodes[jd].prev].right;

              popRight(nodes[jd].prev);

              pushLeft(jd, ld);

                nodes[jd].item = nodes[ld].item;

              }

              if (nodes[nodes[jd].prev].item == nodes[ld].item) {

                setPrio(nodes[jd].prev);

              }

              jd = nodes[jd].right;

            }

          }

        } else {

          jd = nodes[jd].right;

        }

      }

    }

    bool less(int id, int jd) const {

      return comp(nodes[id].prio, nodes[jd].prio);

    }

    bool equal(int id, int jd) const {

      return !less(id, jd) && !less(jd, id);

    }

  public:

    /// \brief Returns true when the given class is alive.

    ///

    /// Returns true when the given class is alive, ie. the class is

    /// not nested into other class.

    bool alive(int cls) const {

      return classes[cls].parent < 0;

    }

    /// \brief Returns true when the given class is trivial.

    ///

    /// Returns true when the given class is trivial, ie. the class

    /// contains just one item directly.

    bool trivial(int cls) const {

      return classes[cls].left == -1;

    }

    /// \brief Constructs the union-find.

    ///

    /// Constructs the union-find.

    /// \brief _index The index map of the union-find. The data

    /// structure uses internally for store references.

    HeapUnionFind(ItemIntMap& _index)

      : index(_index), first_class(-1),

        first_free_class(-1), first_free_node(-1) {}

    /// \brief Insert a new node into a new component.

    ///

    /// Insert a new node into a new component.

    /// \param item The item of the new node.

    /// \param prio The priority of the new node.

    /// \return The class id of the one-item-heap.

    int insert(const Item& item, const Value& prio) {

      int id = newNode();

      nodes[id].item = item;

      nodes[id].prio = prio;

      nodes[id].size = 0;

      nodes[id].prev = -1;

      nodes[id].next = -1;

    /// an STL range which should be contains valid class ids. The

    /// time complexity is O(log(n)*k) where n is the overall number

    /// of the joined nodes and k is the number of classes.

    /// \return The class of the joined classes.

    /// \pre The range should contain at least two class ids.

    template <typename Iterator>

    int join(Iterator begin, Iterator end) {

      std::vector<int> cs;

      for (Iterator it = begin; it != end; ++it) {

        cs.push_back(*it);

      }

      int class_id = newClass();

      { // creation union-find

        if (first_class != -1) {

          classes[first_class].prev = class_id;

        }

        classes[class_id].next = first_class;

        classes[class_id].prev = -1;

        first_class = class_id;

        classes[class_id].depth = classes[cs[0]].depth;

        classes[class_id].parent = classes[cs[0]].parent;

        nodes[~(classes[class_id].parent)].parent = ~class_id;

        int l = cs[0];

        classes[class_id].left = l;

        classes[class_id].right = l;

        if (classes[l].next != -1) {

          classes[classes[l].next].prev = classes[l].prev;

        }

        classes[classes[l].prev].next = classes[l].next;

        classes[l].prev = -1;

        classes[l].next = -1;

        classes[l].depth = leftNode(l);

        classes[l].parent = class_id;

      }

      { // merging of heap

        int l = class_id;

        for (int ci = 1; ci < int(cs.size()); ++ci) {

          int r = cs[ci];

          int rln = leftNode(r);

          if (classes[l].depth > classes[r].depth) {

            int id = ~(classes[l].parent);

            for (int i = classes[r].depth + 1; i < classes[l].depth; ++i) {

              id = nodes[id].right;

            }

            while (id >= 0 && nodes[id].size == cmax) {

              int new_id = newNode();

              int right_id = nodes[id].right;

              popRight(id);

              if (nodes[id].item == nodes[right_id].item) {

                setPrio(id);

              }

              push(new_id, right_id);

              pushRight(new_id, ~(classes[r].parent));

              id = nodes[id].parent;

              classes[r].parent = ~new_id;

            }

            if (id < 0) {

              int new_parent = newNode();

              nodes[new_parent].next = -1;

              nodes[new_parent].prev = -1;

              nodes[new_parent].parent = ~l;

              push(new_parent, ~(classes[l].parent));

              pushRight(new_parent, ~(classes[r].parent));

              setPrio(new_parent);

              classes[l].parent = ~new_parent;

              classes[l].depth += 1;

            } else {

              pushRight(id, ~(classes[r].parent));

              while (id >= 0 && less(~(classes[r].parent), id)) {

                nodes[id].prio = nodes[~(classes[r].parent)].prio;

                nodes[id].item = nodes[~(classes[r].parent)].item;

                id = nodes[id].parent;

              }

            }

          } else if (classes[r].depth > classes[l].depth) {

            int id = ~(classes[r].parent);

            for (int i = classes[l].depth + 1; i < classes[r].depth; ++i) {

              id = nodes[id].left;

            }

            while (id >= 0 && nodes[id].size == cmax) {

              int new_id = newNode();

              int left_id = nodes[id].left;

              popLeft(id);

              if (nodes[id].prio == nodes[left_id].prio) {

                setPrio(id);

              }

              push(new_id, left_id);

              pushLeft(new_id, ~(classes[l].parent));

              id = nodes[id].parent;

              classes[l].parent = ~new_id;

            }

            if (id < 0) {

              int new_parent = newNode();

              nodes[new_parent].next = -1;

              nodes[new_parent].prev = -1;

              nodes[new_parent].parent = ~l;

              push(new_parent, ~(classes[r].parent));

              pushLeft(new_parent, ~(classes[l].parent));

              setPrio(new_parent);

              classes[r].parent = ~new_parent;

              classes[r].depth += 1;

            } else {

              pushLeft(id, ~(classes[l].parent));

              while (id >= 0 && less(~(classes[l].parent), id)) {

                nodes[id].prio = nodes[~(classes[l].parent)].prio;

                nodes[id].item = nodes[~(classes[l].parent)].item;

                id = nodes[id].parent;

              }

            }

            nodes[~(classes[r].parent)].parent = ~l;

            classes[l].parent = classes[r].parent;

            classes[l].depth = classes[r].depth;

          } else {

            if (classes[l].depth != 0 &&

                nodes[~(classes[l].parent)].size +

                nodes[~(classes[r].parent)].size <= cmax) {

              splice(~(classes[l].parent), ~(classes[r].parent));

              deleteNode(~(classes[r].parent));

              if (less(~(classes[r].parent), ~(classes[l].parent))) {

                nodes[~(classes[l].parent)].prio =

                  nodes[~(classes[r].parent)].prio;

                nodes[~(classes[l].parent)].item =

                  nodes[~(classes[r].parent)].item;

              }

            } else {

              int new_parent = newNode();

              nodes[new_parent].next = nodes[new_parent].prev = -1;

              push(new_parent, ~(classes[l].parent));

              pushRight(new_parent, ~(classes[r].parent));

              setPrio(new_parent);

              classes[l].parent = ~new_parent;

              classes[l].depth += 1;

              nodes[new_parent].parent = ~l;

            }

          }

          if (classes[r].next != -1) {

            classes[classes[r].next].prev = classes[r].prev;

          }

          classes[classes[r].prev].next = classes[r].next;

          classes[r].prev = classes[l].right;

          classes[classes[l].right].next = r;

          classes[l].right = r;

          classes[r].parent = l;

          classes[r].next = -1;

          classes[r].depth = rln;