RhodeCode

    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;

    int _unmatched;

    typedef MaxWeightedFractionalMatching<Graph, WeightMap> FractionalMatching;

    FractionalMatching *_fractional;

    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() {

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

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

        _delta2->erase(blossom);

      }

          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(), _unmatched(0),

        _fractional(0)

    {}

    ~MaxWeightedMatching() {

      destroyStructures();

      if (_fractional) {

        delete _fractional;

      }

    }

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

      }

      _unmatched = _node_num;

      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 Initialize the algorithm with fractional matching

    ///

    /// This function initializes the algorithm with a fractional

    /// matching. This initialization is also called jumpstart heuristic.

    void fractionalInit() {

      createStructures();

      if (_fractional == 0) {

        _fractional = new FractionalMatching(_graph, _weight, false);

      }

      _fractional->run();

      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;

    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;

    int _unmatched;

    typedef MaxWeightedPerfectFractionalMatching<Graph, WeightMap> 

    FractionalMatching;

    FractionalMatching *_fractional;

    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() {

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

      }

      if (!_blossom_set->trivial(blossom)) {

        (*_blossom_data)[blossom].pot -=

          2 * (_delta_sum - (*_blossom_data)[blossom].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(), _unmatched(0),

        _fractional(0)

    {}

    ~MaxWeightedPerfectMatching() {

      destroyStructures();

      if (_fractional) {

        delete _fractional;

      }

    }

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

      }

      _unmatched = _node_num;

      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 Initialize the algorithm with fractional matching

    ///

    /// This function initializes the algorithm with a fractional

    /// matching. This initialization is also called jumpstart heuristic.

    void fractionalInit() {

      createStructures();

      if (_fractional == 0) {

        _fractional = new FractionalMatching(_graph, _weight, false);

      }

      if (!_fractional->run()) {

        _unmatched = -1;

        return;

      }

      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;

      }

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