RhodeCode

    IntNodeMap *_blossom_index;

    BlossomSet *_blossom_set;

    RangeMap<BlossomData>* _blossom_data;

    IntNodeMap *_node_index;

    IntArcMap *_node_heap_index;

    struct NodeData {

      NodeData(IntArcMap& node_heap_index)

        : heap(node_heap_index) {}

      int blossom;

      Value pot;

      BinHeap<Value, IntArcMap> heap;

      std::map<int, Arc> heap_index;

      int tree;

    };

    RangeMap<NodeData>* _node_data;

    typedef ExtendFindEnum<IntIntMap> TreeSet;

    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;

      }

      if (_tree_set) {

        delete _tree_set_index;

        delete _tree_set;

      }

      if (_delta1) {

        delete _delta1_index;

        delete _delta1;

      }

      if (_delta2) {

        delete _delta2_index;

        delete _delta2;

      }

      if (_delta3) {

        delete _delta3_index;

        delete _delta3;

      }

      if (_delta4) {

        delete _delta4_index;

        delete _delta4;

      }

    }

    void matchedToEven(int blossom, int tree) {

          Arc matching = (*_blossom_data)[blossoms[i]].next;

          Node base = _graph.source(matching);

          extractBlossom(blossoms[i], base, matching);

        } else {

          Node base = (*_blossom_data)[blossoms[i]].base;

          extractBlossom(blossoms[i], base, INVALID);

        }

      }

    }

  public:

    /// \brief Constructor

    ///

    /// Constructor.

    MaxWeightedMatching(const Graph& graph, const WeightMap& weight)

      : _graph(graph), _weight(weight), _matching(0),

        _node_potential(0), _blossom_potential(), _blossom_node_list(),

        _node_num(0), _blossom_num(0),

        _blossom_index(0), _blossom_set(0), _blossom_data(0),

        _node_index(0), _node_heap_index(0), _node_data(0),

        _tree_set_index(0), _tree_set(0),

        _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);

        }

      }

    }

    /// \brief Start the algorithm

    ///

    /// This function starts the algorithm.

    ///

    /// \pre \ref init() must be called before using this function.

    void start() {

      enum OpType {

        D1, D2, D3, D4

      };

      int unmatched = _node_num;

      while (unmatched > 0) {

        Value d1 = !_delta1->empty() ?

          _delta1->prio() : std::numeric_limits<Value>::max();

        Value d2 = !_delta2->empty() ?

          _delta2->prio() : std::numeric_limits<Value>::max();

        Value d3 = !_delta3->empty() ?

          _delta3->prio() : std::numeric_limits<Value>::max();

        Value d4 = !_delta4->empty() ?

          _delta4->prio() : std::numeric_limits<Value>::max();

      Value pot, offset;

    };

    IntNodeMap *_blossom_index;

    BlossomSet *_blossom_set;

    RangeMap<BlossomData>* _blossom_data;

    IntNodeMap *_node_index;

    IntArcMap *_node_heap_index;

    struct NodeData {

      NodeData(IntArcMap& node_heap_index)

        : heap(node_heap_index) {}

      int blossom;

      Value pot;

      BinHeap<Value, IntArcMap> heap;

      std::map<int, Arc> heap_index;

      int tree;

    };

    RangeMap<NodeData>* _node_data;

    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;

      }

      if (_tree_set) {

        delete _tree_set_index;

        delete _tree_set;

      }

      if (_delta2) {

        delete _delta2_index;

        delete _delta2;

      }

      if (_delta3) {

        delete _delta3_index;

        delete _delta3;

      }

      if (_delta4) {

        delete _delta4_index;

        delete _delta4;

      }

    }

    void matchedToEven(int blossom, int tree) {

      if (_delta2->state(blossom) == _delta2->IN_HEAP) {

        _delta2->erase(blossom);

      }

        (*_blossom_data)[blossoms[i]].pot += 2 * offset;

        for (typename BlossomSet::ItemIt n(*_blossom_set, blossoms[i]);

             n != INVALID; ++n) {

          (*_node_data)[(*_node_index)[n]].pot -= offset;

        }

        Arc matching = (*_blossom_data)[blossoms[i]].next;

        Node base = _graph.source(matching);

        extractBlossom(blossoms[i], base, matching);

      }

    }

  public:

    /// \brief Constructor

    ///

    /// Constructor.

    MaxWeightedPerfectMatching(const Graph& graph, const WeightMap& weight)

      : _graph(graph), _weight(weight), _matching(0),

        _node_potential(0), _blossom_potential(), _blossom_node_list(),

        _node_num(0), _blossom_num(0),

        _blossom_index(0), _blossom_set(0), _blossom_data(0),

        _node_index(0), _node_heap_index(0), _node_data(0),

        _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

    ///

    /// This function starts the algorithm.

    ///

    /// \pre \ref init() must be called before using this function.

    bool start() {

      enum OpType {

        D2, D3, D4

      };

      int unmatched = _node_num;

      while (unmatched > 0) {

        Value d2 = !_delta2->empty() ?

          _delta2->prio() : std::numeric_limits<Value>::max();

        Value d3 = !_delta3->empty() ?

          _delta3->prio() : std::numeric_limits<Value>::max();

        Value d4 = !_delta4->empty() ?

          _delta4->prio() : std::numeric_limits<Value>::max();

        _delta_sum = d2; OpType ot = D2;

        if (d3 < _delta_sum) { _delta_sum = d3; ot = D3; }

        if (d4 < _delta_sum) { _delta_sum = d4; ot = D4; }

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

    ///

    /// This method creates a new component consisting only of the

    /// given element.

    int insert(const Item& item) {

      int cdx = newClass();

      classes[cdx].prev = -1;

      classes[cdx].next = firstClass;

      if (firstClass != -1) {

        classes[firstClass].prev = cdx;

      }

      firstClass = cdx;

      int idx = newItem();

      items[idx].item = item;

      items[idx].cls = cdx;

      items[idx].prev = idx;

      items[idx].next = idx;

      classes[cdx].firstItem = idx;

      index.set(item, idx);

      return cdx;

    }

    /// \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.

    void erase(const Item &item) {

      int idx = index[item];

      int cdx = items[idx].cls;

      if (idx == items[idx].next) {

        if (classes[cdx].prev != -1) {

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

        } else {

          firstClass = classes[cdx].next;

        }

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

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

        }

        classes[cdx].next = firstFreeClass;

        firstFreeClass = cdx;

      } else {

        classes[cdx].firstItem = items[idx].next;

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

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

      }

      items[idx].next = firstFreeItem;

      firstFreeItem = idx;

    }

                  nodes[ld].item == nodes[pd].item) {

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

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

              }

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

    }

  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;

      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;

      classes[class_id].left = -1;

      classes[class_id].right = -1;

      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;

      nodes[id].parent = ~class_id;

      return class_id;

    }

    /// \brief The class of the item.

    ///

    /// \return The alive class id of the item, which is not nested into

    /// other classes.

    ///

    /// The time complexity is O(log(n)).

    int find(const Item& item) const {

      return findClass(index[item]);