RhodeCode

    IntIntMap *_tree_set_index;

    TreeSet *_tree_set;

    IntNodeMap *_delta1_index;

    BinHeap<Value, IntNodeMap> *_delta1;

    IntIntMap *_delta2_index;

    BinHeap<Value, IntIntMap> *_delta2;

    IntEdgeMap *_delta3_index;

    BinHeap<Value, IntEdgeMap> *_delta3;

    IntIntMap *_delta4_index;

    BinHeap<Value, IntIntMap> *_delta4;

    Value _delta_sum;

    void createStructures() {

      _node_num = countNodes(_graph);

      _blossom_num = _node_num * 3 / 2;

      if (!_matching) {

        _matching = new MatchingMap(_graph);

      }

      if (!_node_potential) {

        _node_potential = new NodePotential(_graph);

      }

      if (!_blossom_set) {

        _blossom_index = new IntNodeMap(_graph);

        _blossom_set = new BlossomSet(*_blossom_index);

        _blossom_data = new RangeMap<BlossomData>(_blossom_num);

      }

      if (!_node_index) {

        _node_index = new IntNodeMap(_graph);

        _node_heap_index = new IntArcMap(_graph);

        _node_data = new RangeMap<NodeData>(_node_num,

      }

      if (!_tree_set) {

        _tree_set_index = new IntIntMap(_blossom_num);

        _tree_set = new TreeSet(*_tree_set_index);

      }

      if (!_delta1) {

        _delta1_index = new IntNodeMap(_graph);

        _delta1 = new BinHeap<Value, IntNodeMap>(*_delta1_index);

      }

      if (!_delta2) {

        _delta2_index = new IntIntMap(_blossom_num);

        _delta2 = new BinHeap<Value, IntIntMap>(*_delta2_index);

      }

      if (!_delta3) {

        _delta3_index = new IntEdgeMap(_graph);

        _delta3 = new BinHeap<Value, IntEdgeMap>(*_delta3_index);

      }

      if (!_delta4) {

        _delta4_index = new IntIntMap(_blossom_num);

        _delta4 = new BinHeap<Value, IntIntMap>(*_delta4_index);

      }

    }

    void destroyStructures() {

      _node_num = countNodes(_graph);

      _blossom_num = _node_num * 3 / 2;

      if (_matching) {

        delete _matching;

      }

      if (_node_potential) {

        delete _node_potential;

      }

      if (_blossom_set) {

        delete _blossom_index;

        delete _blossom_set;

        delete _blossom_data;

      }

      if (_node_index) {

        delete _node_index;

        delete _node_heap_index;

        delete _node_data;

      }

        _delta1_index(0), _delta1(0),

        _delta2_index(0), _delta2(0),

        _delta3_index(0), _delta3(0),

        _delta4_index(0), _delta4(0),

        _delta_sum() {}

    ~MaxWeightedMatching() {

      destroyStructures();

    }

    /// \name Execution Control

    /// The simplest way to execute the algorithm is to use the

    /// \ref run() member function.

    ///@{

    /// \brief Initialize the algorithm

    ///

    /// This function initializes the algorithm.

    void init() {

      createStructures();

      for (ArcIt e(_graph); e != INVALID; ++e) {

        (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::PRE_HEAP;

      }

      for (NodeIt n(_graph); n != INVALID; ++n) {

        (*_delta1_index)[n] = _delta1->PRE_HEAP;

      }

      for (EdgeIt e(_graph); e != INVALID; ++e) {

        (*_delta3_index)[e] = _delta3->PRE_HEAP;

      }

      for (int i = 0; i < _blossom_num; ++i) {

        (*_delta2_index)[i] = _delta2->PRE_HEAP;

        (*_delta4_index)[i] = _delta4->PRE_HEAP;

      }

      int index = 0;

      for (NodeIt n(_graph); n != INVALID; ++n) {

        Value max = 0;

        for (OutArcIt e(_graph, n); e != INVALID; ++e) {

          if (_graph.target(e) == n) continue;

          if ((dualScale * _weight[e]) / 2 > max) {

            max = (dualScale * _weight[e]) / 2;

          }

        }

        (*_node_index)[n] = index;

        (*_node_data)[index].pot = max;

        _delta1->push(n, max);

        int blossom =

          _blossom_set->insert(n, std::numeric_limits<Value>::max());

        _tree_set->insert(blossom);

        (*_blossom_data)[blossom].status = EVEN;

        (*_blossom_data)[blossom].pred = INVALID;

        (*_blossom_data)[blossom].next = INVALID;

        (*_blossom_data)[blossom].pot = 0;

        (*_blossom_data)[blossom].offset = 0;

        ++index;

      }

      for (EdgeIt e(_graph); e != INVALID; ++e) {

        int si = (*_node_index)[_graph.u(e)];

        int ti = (*_node_index)[_graph.v(e)];

        if (_graph.u(e) != _graph.v(e)) {

          _delta3->push(e, ((*_node_data)[si].pot + (*_node_data)[ti].pot -

                            dualScale * _weight[e]) / 2);

        }

      }

    }

    typedef ExtendFindEnum<IntIntMap> TreeSet;

    IntIntMap *_tree_set_index;

    TreeSet *_tree_set;

    IntIntMap *_delta2_index;

    BinHeap<Value, IntIntMap> *_delta2;

    IntEdgeMap *_delta3_index;

    BinHeap<Value, IntEdgeMap> *_delta3;

    IntIntMap *_delta4_index;

    BinHeap<Value, IntIntMap> *_delta4;

    Value _delta_sum;

    void createStructures() {

      _node_num = countNodes(_graph);

      _blossom_num = _node_num * 3 / 2;

      if (!_matching) {

        _matching = new MatchingMap(_graph);

      }

      if (!_node_potential) {

        _node_potential = new NodePotential(_graph);

      }

      if (!_blossom_set) {

        _blossom_index = new IntNodeMap(_graph);

        _blossom_set = new BlossomSet(*_blossom_index);

        _blossom_data = new RangeMap<BlossomData>(_blossom_num);

      }

      if (!_node_index) {

        _node_index = new IntNodeMap(_graph);

        _node_heap_index = new IntArcMap(_graph);

        _node_data = new RangeMap<NodeData>(_node_num,

                                            NodeData(*_node_heap_index));

      }

      if (!_tree_set) {

        _tree_set_index = new IntIntMap(_blossom_num);

        _tree_set = new TreeSet(*_tree_set_index);

      }

      if (!_delta2) {

        _delta2_index = new IntIntMap(_blossom_num);

        _delta2 = new BinHeap<Value, IntIntMap>(*_delta2_index);

      }

      if (!_delta3) {

        _delta3_index = new IntEdgeMap(_graph);

        _delta3 = new BinHeap<Value, IntEdgeMap>(*_delta3_index);

      }

      if (!_delta4) {

        _delta4_index = new IntIntMap(_blossom_num);

        _delta4 = new BinHeap<Value, IntIntMap>(*_delta4_index);

      }

    }

    void destroyStructures() {

      _node_num = countNodes(_graph);

      _blossom_num = _node_num * 3 / 2;

      if (_matching) {

        delete _matching;

      }

      if (_node_potential) {

        delete _node_potential;

      }

      if (_blossom_set) {

        delete _blossom_index;

        delete _blossom_set;

        delete _blossom_data;

      }

      if (_node_index) {

        delete _node_index;

        delete _node_heap_index;

        delete _node_data;

      }

        _tree_set_index(0), _tree_set(0),

        _delta2_index(0), _delta2(0),

        _delta3_index(0), _delta3(0),

        _delta4_index(0), _delta4(0),

        _delta_sum() {}

    ~MaxWeightedPerfectMatching() {

      destroyStructures();

    }

    /// \name Execution Control

    /// The simplest way to execute the algorithm is to use the

    /// \ref run() member function.

    ///@{

    /// \brief Initialize the algorithm

    ///

    /// This function initializes the algorithm.

    void init() {

      createStructures();

      for (ArcIt e(_graph); e != INVALID; ++e) {

        (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::PRE_HEAP;

      }

      for (EdgeIt e(_graph); e != INVALID; ++e) {

        (*_delta3_index)[e] = _delta3->PRE_HEAP;

      }

      for (int i = 0; i < _blossom_num; ++i) {

        (*_delta2_index)[i] = _delta2->PRE_HEAP;

        (*_delta4_index)[i] = _delta4->PRE_HEAP;

      }

      int index = 0;

      for (NodeIt n(_graph); n != INVALID; ++n) {

        Value max = - std::numeric_limits<Value>::max();

        for (OutArcIt e(_graph, n); e != INVALID; ++e) {

          if (_graph.target(e) == n) continue;

          if ((dualScale * _weight[e]) / 2 > max) {

            max = (dualScale * _weight[e]) / 2;

          }

        }

        (*_node_index)[n] = index;

        (*_node_data)[index].pot = max;

        int blossom =

          _blossom_set->insert(n, std::numeric_limits<Value>::max());

        _tree_set->insert(blossom);

        (*_blossom_data)[blossom].status = EVEN;

        (*_blossom_data)[blossom].pred = INVALID;

        (*_blossom_data)[blossom].next = INVALID;

        (*_blossom_data)[blossom].pot = 0;

        (*_blossom_data)[blossom].offset = 0;

        ++index;

      }

      for (EdgeIt e(_graph); e != INVALID; ++e) {

        int si = (*_node_index)[_graph.u(e)];

        int ti = (*_node_index)[_graph.v(e)];

        if (_graph.u(e) != _graph.v(e)) {

          _delta3->push(e, ((*_node_data)[si].pot + (*_node_data)[ti].pot -

                            dualScale * _weight[e]) / 2);

        }

      }

    }

    /// \brief Start the algorithm

    }

    /// \brief Inserts the given element into the given component.

    ///

    /// This methods inserts the element \e item a into the \e cls class.

    void insert(const Item& item, int cls) {

      int idx = newItem();

      int rdx = classes[cls].firstItem;

      items[idx].item = item;

      items[idx].cls = cls;

      items[idx].prev = rdx;

      items[idx].next = items[rdx].next;

      items[items[rdx].next].prev = idx;

      items[rdx].next = idx;

      index.set(item, idx);

    }

    /// \brief Clears the union-find data structure

    ///

    /// Erase each item from the data structure.

    void clear() {

      items.clear();

      firstClass = firstFreeClass = firstFreeItem = -1;

    }

    /// \brief Gives back the class of the \e item.

    ///

    /// Gives back the class of the \e item.

    int find(const Item &item) const {

      return items[index[item]].cls;

    }

    /// \brief Gives back a representant item of the component.

    ///

    /// Gives back a representant item of the component.

    Item item(int cls) const {

      return items[classes[cls].firstItem].item;

    }

    /// \brief Removes the given element from the structure.

    ///

    /// Removes the element from its component and if the component becomes

    /// empty then removes that component from the component list.

    ///

    /// \warning It is an error to remove an element which is not in

    /// the structure.

    ///

    /// 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;

      nodes[id].left = -1;

      nodes[id].right = -1;

      nodes[id].item = item;

      index[item] = id;

      int class_id = newClass();

      classes[class_id].parent = ~id;

      classes[class_id].depth = 0;