1825 lines
49 KiB
C++
Executable File
1825 lines
49 KiB
C++
Executable File
/* -*- mode: C++; indent-tabs-mode: nil; -*-
|
|
*
|
|
* This file is a part of LEMON, a generic C++ optimization library.
|
|
*
|
|
* Copyright (C) 2003-2013
|
|
* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
|
|
* (Egervary Research Group on Combinatorial Optimization, EGRES).
|
|
*
|
|
* Permission to use, modify and distribute this software is granted
|
|
* provided that this copyright notice appears in all copies. For
|
|
* precise terms see the accompanying LICENSE file.
|
|
*
|
|
* This software is provided "AS IS" with no warranty of any kind,
|
|
* express or implied, and with no claim as to its suitability for any
|
|
* purpose.
|
|
*
|
|
*/
|
|
|
|
#ifndef LEMON_UNION_FIND_H
|
|
#define LEMON_UNION_FIND_H
|
|
|
|
//!\ingroup auxdat
|
|
//!\file
|
|
//!\brief Union-Find data structures.
|
|
//!
|
|
|
|
#include <vector>
|
|
#include <list>
|
|
#include <utility>
|
|
#include <algorithm>
|
|
#include <functional>
|
|
|
|
#include <lemon/core.h>
|
|
|
|
namespace lemon {
|
|
|
|
/// \ingroup auxdat
|
|
///
|
|
/// \brief A \e Union-Find data structure implementation
|
|
///
|
|
/// The class implements the \e Union-Find data structure.
|
|
/// The union operation uses rank heuristic, while
|
|
/// the find operation uses path compression.
|
|
/// This is a very simple but efficient implementation, providing
|
|
/// only four methods: join (union), find, insert and size.
|
|
/// For more features, see the \ref UnionFindEnum class.
|
|
///
|
|
/// It is primarily used in Kruskal algorithm for finding minimal
|
|
/// cost spanning tree in a graph.
|
|
/// \sa kruskal()
|
|
///
|
|
/// \pre You need to add all the elements by the \ref insert()
|
|
/// method.
|
|
template <typename IM>
|
|
class UnionFind {
|
|
public:
|
|
|
|
///\e
|
|
typedef IM ItemIntMap;
|
|
///\e
|
|
typedef typename ItemIntMap::Key Item;
|
|
|
|
private:
|
|
// If the items vector stores negative value for an item then
|
|
// that item is root item and it has -items[it] component size.
|
|
// Else the items[it] contains the index of the parent.
|
|
std::vector<int> items;
|
|
ItemIntMap& index;
|
|
|
|
bool rep(int idx) const {
|
|
return items[idx] < 0;
|
|
}
|
|
|
|
int repIndex(int idx) const {
|
|
int k = idx;
|
|
while (!rep(k)) {
|
|
k = items[k] ;
|
|
}
|
|
while (idx != k) {
|
|
int next = items[idx];
|
|
const_cast<int&>(items[idx]) = k;
|
|
idx = next;
|
|
}
|
|
return k;
|
|
}
|
|
|
|
public:
|
|
|
|
/// \brief Constructor
|
|
///
|
|
/// Constructor of the UnionFind class. You should give an item to
|
|
/// integer map which will be used from the data structure. If you
|
|
/// modify directly this map that may cause segmentation fault,
|
|
/// invalid data structure, or infinite loop when you use again
|
|
/// the union-find.
|
|
UnionFind(ItemIntMap& m) : index(m) {}
|
|
|
|
/// \brief Returns the index of the element's component.
|
|
///
|
|
/// The method returns the index of the element's component.
|
|
/// This is an integer between zero and the number of inserted elements.
|
|
///
|
|
int find(const Item& a) {
|
|
return repIndex(index[a]);
|
|
}
|
|
|
|
/// \brief Clears the union-find data structure
|
|
///
|
|
/// Erase each item from the data structure.
|
|
void clear() {
|
|
items.clear();
|
|
}
|
|
|
|
/// \brief Inserts a new element into the structure.
|
|
///
|
|
/// This method inserts a new element into the data structure.
|
|
///
|
|
/// The method returns the index of the new component.
|
|
int insert(const Item& a) {
|
|
int n = items.size();
|
|
items.push_back(-1);
|
|
index.set(a,n);
|
|
return n;
|
|
}
|
|
|
|
/// \brief Joining the components of element \e a and element \e b.
|
|
///
|
|
/// This is the \e union operation of the Union-Find structure.
|
|
/// Joins the component of element \e a and component of
|
|
/// element \e b. If \e a and \e b are in the same component then
|
|
/// it returns false otherwise it returns true.
|
|
bool join(const Item& a, const Item& b) {
|
|
int ka = repIndex(index[a]);
|
|
int kb = repIndex(index[b]);
|
|
|
|
if ( ka == kb )
|
|
return false;
|
|
|
|
if (items[ka] < items[kb]) {
|
|
items[ka] += items[kb];
|
|
items[kb] = ka;
|
|
} else {
|
|
items[kb] += items[ka];
|
|
items[ka] = kb;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// \brief Returns the size of the component of element \e a.
|
|
///
|
|
/// Returns the size of the component of element \e a.
|
|
int size(const Item& a) {
|
|
int k = repIndex(index[a]);
|
|
return - items[k];
|
|
}
|
|
|
|
};
|
|
|
|
/// \ingroup auxdat
|
|
///
|
|
/// \brief A \e Union-Find data structure implementation which
|
|
/// is able to enumerate the components.
|
|
///
|
|
/// The class implements a \e Union-Find data structure
|
|
/// which is able to enumerate the components and the items in
|
|
/// a component. If you don't need this feature then perhaps it's
|
|
/// better to use the \ref UnionFind class which is more efficient.
|
|
///
|
|
/// The union operation uses rank heuristic, while
|
|
/// the find operation uses path compression.
|
|
///
|
|
/// \pre You need to add all the elements by the \ref insert()
|
|
/// method.
|
|
///
|
|
template <typename IM>
|
|
class UnionFindEnum {
|
|
public:
|
|
|
|
///\e
|
|
typedef IM ItemIntMap;
|
|
///\e
|
|
typedef typename ItemIntMap::Key Item;
|
|
|
|
private:
|
|
|
|
ItemIntMap& index;
|
|
|
|
// If the parent stores negative value for an item then that item
|
|
// is root item and it has ~(items[it].parent) component id. Else
|
|
// the items[it].parent contains the index of the parent.
|
|
//
|
|
// The \c next and \c prev provides the double-linked
|
|
// cyclic list of one component's items.
|
|
struct ItemT {
|
|
int parent;
|
|
Item item;
|
|
|
|
int next, prev;
|
|
};
|
|
|
|
std::vector<ItemT> items;
|
|
int firstFreeItem;
|
|
|
|
struct ClassT {
|
|
int size;
|
|
int firstItem;
|
|
int next, prev;
|
|
};
|
|
|
|
std::vector<ClassT> classes;
|
|
int firstClass, firstFreeClass;
|
|
|
|
int newClass() {
|
|
if (firstFreeClass == -1) {
|
|
int cdx = classes.size();
|
|
classes.push_back(ClassT());
|
|
return cdx;
|
|
} else {
|
|
int cdx = firstFreeClass;
|
|
firstFreeClass = classes[firstFreeClass].next;
|
|
return cdx;
|
|
}
|
|
}
|
|
|
|
int newItem() {
|
|
if (firstFreeItem == -1) {
|
|
int idx = items.size();
|
|
items.push_back(ItemT());
|
|
return idx;
|
|
} else {
|
|
int idx = firstFreeItem;
|
|
firstFreeItem = items[firstFreeItem].next;
|
|
return idx;
|
|
}
|
|
}
|
|
|
|
|
|
bool rep(int idx) const {
|
|
return items[idx].parent < 0;
|
|
}
|
|
|
|
int repIndex(int idx) const {
|
|
int k = idx;
|
|
while (!rep(k)) {
|
|
k = items[k].parent;
|
|
}
|
|
while (idx != k) {
|
|
int next = items[idx].parent;
|
|
const_cast<int&>(items[idx].parent) = k;
|
|
idx = next;
|
|
}
|
|
return k;
|
|
}
|
|
|
|
int classIndex(int idx) const {
|
|
return ~(items[repIndex(idx)].parent);
|
|
}
|
|
|
|
void singletonItem(int idx) {
|
|
items[idx].next = idx;
|
|
items[idx].prev = idx;
|
|
}
|
|
|
|
void laceItem(int idx, int rdx) {
|
|
items[idx].prev = rdx;
|
|
items[idx].next = items[rdx].next;
|
|
items[items[rdx].next].prev = idx;
|
|
items[rdx].next = idx;
|
|
}
|
|
|
|
void unlaceItem(int idx) {
|
|
items[items[idx].prev].next = items[idx].next;
|
|
items[items[idx].next].prev = items[idx].prev;
|
|
|
|
items[idx].next = firstFreeItem;
|
|
firstFreeItem = idx;
|
|
}
|
|
|
|
void spliceItems(int ak, int bk) {
|
|
items[items[ak].prev].next = bk;
|
|
items[items[bk].prev].next = ak;
|
|
int tmp = items[ak].prev;
|
|
items[ak].prev = items[bk].prev;
|
|
items[bk].prev = tmp;
|
|
|
|
}
|
|
|
|
void laceClass(int cls) {
|
|
if (firstClass != -1) {
|
|
classes[firstClass].prev = cls;
|
|
}
|
|
classes[cls].next = firstClass;
|
|
classes[cls].prev = -1;
|
|
firstClass = cls;
|
|
}
|
|
|
|
void unlaceClass(int cls) {
|
|
if (classes[cls].prev != -1) {
|
|
classes[classes[cls].prev].next = classes[cls].next;
|
|
} else {
|
|
firstClass = classes[cls].next;
|
|
}
|
|
if (classes[cls].next != -1) {
|
|
classes[classes[cls].next].prev = classes[cls].prev;
|
|
}
|
|
|
|
classes[cls].next = firstFreeClass;
|
|
firstFreeClass = cls;
|
|
}
|
|
|
|
public:
|
|
|
|
UnionFindEnum(ItemIntMap& _index)
|
|
: index(_index), items(), firstFreeItem(-1),
|
|
firstClass(-1), firstFreeClass(-1) {}
|
|
|
|
/// \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 idx = newItem();
|
|
|
|
index.set(item, idx);
|
|
|
|
singletonItem(idx);
|
|
items[idx].item = item;
|
|
|
|
int cdx = newClass();
|
|
|
|
items[idx].parent = ~cdx;
|
|
|
|
laceClass(cdx);
|
|
classes[cdx].size = 1;
|
|
classes[cdx].firstItem = idx;
|
|
|
|
firstClass = cdx;
|
|
|
|
return cdx;
|
|
}
|
|
|
|
/// \brief Inserts the given element into the component of the others.
|
|
///
|
|
/// This methods inserts the element \e a into the component of the
|
|
/// element \e comp.
|
|
void insert(const Item& item, int cls) {
|
|
int rdx = classes[cls].firstItem;
|
|
int idx = newItem();
|
|
|
|
index.set(item, idx);
|
|
|
|
laceItem(idx, rdx);
|
|
|
|
items[idx].item = item;
|
|
items[idx].parent = rdx;
|
|
|
|
++classes[~(items[rdx].parent)].size;
|
|
}
|
|
|
|
/// \brief Clears the union-find data structure
|
|
///
|
|
/// Erase each item from the data structure.
|
|
void clear() {
|
|
items.clear();
|
|
firstClass = -1;
|
|
firstFreeItem = -1;
|
|
}
|
|
|
|
/// \brief Finds the component of the given element.
|
|
///
|
|
/// The method returns the component id of the given element.
|
|
int find(const Item &item) const {
|
|
return ~(items[repIndex(index[item])].parent);
|
|
}
|
|
|
|
/// \brief Joining the component of element \e a and element \e b.
|
|
///
|
|
/// This is the \e union operation of the Union-Find structure.
|
|
/// Joins the component of element \e a and component of
|
|
/// element \e b. If \e a and \e b are in the same component then
|
|
/// returns -1 else returns the remaining class.
|
|
int join(const Item& a, const Item& b) {
|
|
|
|
int ak = repIndex(index[a]);
|
|
int bk = repIndex(index[b]);
|
|
|
|
if (ak == bk) {
|
|
return -1;
|
|
}
|
|
|
|
int acx = ~(items[ak].parent);
|
|
int bcx = ~(items[bk].parent);
|
|
|
|
int rcx;
|
|
|
|
if (classes[acx].size > classes[bcx].size) {
|
|
classes[acx].size += classes[bcx].size;
|
|
items[bk].parent = ak;
|
|
unlaceClass(bcx);
|
|
rcx = acx;
|
|
} else {
|
|
classes[bcx].size += classes[acx].size;
|
|
items[ak].parent = bk;
|
|
unlaceClass(acx);
|
|
rcx = bcx;
|
|
}
|
|
spliceItems(ak, bk);
|
|
|
|
return rcx;
|
|
}
|
|
|
|
/// \brief Returns the size of the class.
|
|
///
|
|
/// Returns the size of the class.
|
|
int size(int cls) const {
|
|
return classes[cls].size;
|
|
}
|
|
|
|
/// \brief Splits up the component.
|
|
///
|
|
/// Splitting the component into singleton components (component
|
|
/// of size one).
|
|
void split(int cls) {
|
|
int fdx = classes[cls].firstItem;
|
|
int idx = items[fdx].next;
|
|
while (idx != fdx) {
|
|
int next = items[idx].next;
|
|
|
|
singletonItem(idx);
|
|
|
|
int cdx = newClass();
|
|
items[idx].parent = ~cdx;
|
|
|
|
laceClass(cdx);
|
|
classes[cdx].size = 1;
|
|
classes[cdx].firstItem = idx;
|
|
|
|
idx = next;
|
|
}
|
|
|
|
items[idx].prev = idx;
|
|
items[idx].next = idx;
|
|
|
|
classes[~(items[idx].parent)].size = 1;
|
|
|
|
}
|
|
|
|
/// \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.
|
|
/// \warning This running time of this operation is proportional to the
|
|
/// number of the items in this class.
|
|
void erase(const Item& item) {
|
|
int idx = index[item];
|
|
int fdx = items[idx].next;
|
|
|
|
int cdx = classIndex(idx);
|
|
if (idx == fdx) {
|
|
unlaceClass(cdx);
|
|
items[idx].next = firstFreeItem;
|
|
firstFreeItem = idx;
|
|
return;
|
|
} else {
|
|
classes[cdx].firstItem = fdx;
|
|
--classes[cdx].size;
|
|
items[fdx].parent = ~cdx;
|
|
|
|
unlaceItem(idx);
|
|
idx = items[fdx].next;
|
|
while (idx != fdx) {
|
|
items[idx].parent = fdx;
|
|
idx = items[idx].next;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/// \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 component of the given element from the structure.
|
|
///
|
|
/// Removes the component of the given element from the structure.
|
|
///
|
|
/// \warning It is an error to give an element which is not in the
|
|
/// structure.
|
|
void eraseClass(int cls) {
|
|
int fdx = classes[cls].firstItem;
|
|
unlaceClass(cls);
|
|
items[items[fdx].prev].next = firstFreeItem;
|
|
firstFreeItem = fdx;
|
|
}
|
|
|
|
/// \brief LEMON style iterator for the representant items.
|
|
///
|
|
/// ClassIt is a lemon style iterator for the components. It iterates
|
|
/// on the ids of the classes.
|
|
class ClassIt {
|
|
public:
|
|
/// \brief Constructor of the iterator
|
|
///
|
|
/// Constructor of the iterator
|
|
ClassIt(const UnionFindEnum& ufe) : unionFind(&ufe) {
|
|
cdx = unionFind->firstClass;
|
|
}
|
|
|
|
/// \brief Constructor to get invalid iterator
|
|
///
|
|
/// Constructor to get invalid iterator
|
|
ClassIt(Invalid) : unionFind(0), cdx(-1) {}
|
|
|
|
/// \brief Increment operator
|
|
///
|
|
/// It steps to the next representant item.
|
|
ClassIt& operator++() {
|
|
cdx = unionFind->classes[cdx].next;
|
|
return *this;
|
|
}
|
|
|
|
/// \brief Conversion operator
|
|
///
|
|
/// It converts the iterator to the current representant item.
|
|
operator int() const {
|
|
return cdx;
|
|
}
|
|
|
|
/// \brief Equality operator
|
|
///
|
|
/// Equality operator
|
|
bool operator==(const ClassIt& i) {
|
|
return i.cdx == cdx;
|
|
}
|
|
|
|
/// \brief Inequality operator
|
|
///
|
|
/// Inequality operator
|
|
bool operator!=(const ClassIt& i) {
|
|
return i.cdx != cdx;
|
|
}
|
|
|
|
private:
|
|
const UnionFindEnum* unionFind;
|
|
int cdx;
|
|
};
|
|
|
|
/// \brief LEMON style iterator for the items of a component.
|
|
///
|
|
/// ClassIt is a lemon style iterator for the components. It iterates
|
|
/// on the items of a class. By example if you want to iterate on
|
|
/// each items of each classes then you may write the next code.
|
|
///\code
|
|
/// for (ClassIt cit(ufe); cit != INVALID; ++cit) {
|
|
/// std::cout << "Class: ";
|
|
/// for (ItemIt iit(ufe, cit); iit != INVALID; ++iit) {
|
|
/// std::cout << toString(iit) << ' ' << std::endl;
|
|
/// }
|
|
/// std::cout << std::endl;
|
|
/// }
|
|
///\endcode
|
|
class ItemIt {
|
|
public:
|
|
/// \brief Constructor of the iterator
|
|
///
|
|
/// Constructor of the iterator. The iterator iterates
|
|
/// on the class of the \c item.
|
|
ItemIt(const UnionFindEnum& ufe, int cls) : unionFind(&ufe) {
|
|
fdx = idx = unionFind->classes[cls].firstItem;
|
|
}
|
|
|
|
/// \brief Constructor to get invalid iterator
|
|
///
|
|
/// Constructor to get invalid iterator
|
|
ItemIt(Invalid) : unionFind(0), idx(-1) {}
|
|
|
|
/// \brief Increment operator
|
|
///
|
|
/// It steps to the next item in the class.
|
|
ItemIt& operator++() {
|
|
idx = unionFind->items[idx].next;
|
|
if (idx == fdx) idx = -1;
|
|
return *this;
|
|
}
|
|
|
|
/// \brief Conversion operator
|
|
///
|
|
/// It converts the iterator to the current item.
|
|
operator const Item&() const {
|
|
return unionFind->items[idx].item;
|
|
}
|
|
|
|
/// \brief Equality operator
|
|
///
|
|
/// Equality operator
|
|
bool operator==(const ItemIt& i) {
|
|
return i.idx == idx;
|
|
}
|
|
|
|
/// \brief Inequality operator
|
|
///
|
|
/// Inequality operator
|
|
bool operator!=(const ItemIt& i) {
|
|
return i.idx != idx;
|
|
}
|
|
|
|
private:
|
|
const UnionFindEnum* unionFind;
|
|
int idx, fdx;
|
|
};
|
|
|
|
};
|
|
|
|
/// \ingroup auxdat
|
|
///
|
|
/// \brief A \e Extend-Find data structure implementation which
|
|
/// is able to enumerate the components.
|
|
///
|
|
/// The class implements an \e Extend-Find data structure which is
|
|
/// able to enumerate the components and the items in a
|
|
/// component. The data structure is a simplification of the
|
|
/// Union-Find structure, and it does not allow to merge two components.
|
|
///
|
|
/// \pre You need to add all the elements by the \ref insert()
|
|
/// method.
|
|
template <typename IM>
|
|
class ExtendFindEnum {
|
|
public:
|
|
|
|
///\e
|
|
typedef IM ItemIntMap;
|
|
///\e
|
|
typedef typename ItemIntMap::Key Item;
|
|
|
|
private:
|
|
|
|
ItemIntMap& index;
|
|
|
|
struct ItemT {
|
|
int cls;
|
|
Item item;
|
|
int next, prev;
|
|
};
|
|
|
|
std::vector<ItemT> items;
|
|
int firstFreeItem;
|
|
|
|
struct ClassT {
|
|
int firstItem;
|
|
int next, prev;
|
|
};
|
|
|
|
std::vector<ClassT> classes;
|
|
|
|
int firstClass, firstFreeClass;
|
|
|
|
int newClass() {
|
|
if (firstFreeClass != -1) {
|
|
int cdx = firstFreeClass;
|
|
firstFreeClass = classes[cdx].next;
|
|
return cdx;
|
|
} else {
|
|
classes.push_back(ClassT());
|
|
return classes.size() - 1;
|
|
}
|
|
}
|
|
|
|
int newItem() {
|
|
if (firstFreeItem != -1) {
|
|
int idx = firstFreeItem;
|
|
firstFreeItem = items[idx].next;
|
|
return idx;
|
|
} else {
|
|
items.push_back(ItemT());
|
|
return items.size() - 1;
|
|
}
|
|
}
|
|
|
|
public:
|
|
|
|
/// \brief Constructor
|
|
ExtendFindEnum(ItemIntMap& _index)
|
|
: index(_index), items(), firstFreeItem(-1),
|
|
classes(), firstClass(-1), firstFreeClass(-1) {}
|
|
|
|
/// \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();
|
|
classes.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;
|
|
|
|
}
|
|
|
|
|
|
/// \brief Removes the component of the given element from the structure.
|
|
///
|
|
/// Removes the component of the given element from the structure.
|
|
///
|
|
/// \warning It is an error to give an element which is not in the
|
|
/// structure.
|
|
void eraseClass(int cdx) {
|
|
int idx = classes[cdx].firstItem;
|
|
items[items[idx].prev].next = firstFreeItem;
|
|
firstFreeItem = idx;
|
|
|
|
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;
|
|
}
|
|
|
|
/// \brief LEMON style iterator for the classes.
|
|
///
|
|
/// ClassIt is a lemon style iterator for the components. It iterates
|
|
/// on the ids of classes.
|
|
class ClassIt {
|
|
public:
|
|
/// \brief Constructor of the iterator
|
|
///
|
|
/// Constructor of the iterator
|
|
ClassIt(const ExtendFindEnum& ufe) : extendFind(&ufe) {
|
|
cdx = extendFind->firstClass;
|
|
}
|
|
|
|
/// \brief Constructor to get invalid iterator
|
|
///
|
|
/// Constructor to get invalid iterator
|
|
ClassIt(Invalid) : extendFind(0), cdx(-1) {}
|
|
|
|
/// \brief Increment operator
|
|
///
|
|
/// It steps to the next representant item.
|
|
ClassIt& operator++() {
|
|
cdx = extendFind->classes[cdx].next;
|
|
return *this;
|
|
}
|
|
|
|
/// \brief Conversion operator
|
|
///
|
|
/// It converts the iterator to the current class id.
|
|
operator int() const {
|
|
return cdx;
|
|
}
|
|
|
|
/// \brief Equality operator
|
|
///
|
|
/// Equality operator
|
|
bool operator==(const ClassIt& i) {
|
|
return i.cdx == cdx;
|
|
}
|
|
|
|
/// \brief Inequality operator
|
|
///
|
|
/// Inequality operator
|
|
bool operator!=(const ClassIt& i) {
|
|
return i.cdx != cdx;
|
|
}
|
|
|
|
private:
|
|
const ExtendFindEnum* extendFind;
|
|
int cdx;
|
|
};
|
|
|
|
/// \brief LEMON style iterator for the items of a component.
|
|
///
|
|
/// ClassIt is a lemon style iterator for the components. It iterates
|
|
/// on the items of a class. By example if you want to iterate on
|
|
/// each items of each classes then you may write the next code.
|
|
///\code
|
|
/// for (ClassIt cit(ufe); cit != INVALID; ++cit) {
|
|
/// std::cout << "Class: ";
|
|
/// for (ItemIt iit(ufe, cit); iit != INVALID; ++iit) {
|
|
/// std::cout << toString(iit) << ' ' << std::endl;
|
|
/// }
|
|
/// std::cout << std::endl;
|
|
/// }
|
|
///\endcode
|
|
class ItemIt {
|
|
public:
|
|
/// \brief Constructor of the iterator
|
|
///
|
|
/// Constructor of the iterator. The iterator iterates
|
|
/// on the class of the \c item.
|
|
ItemIt(const ExtendFindEnum& ufe, int cls) : extendFind(&ufe) {
|
|
fdx = idx = extendFind->classes[cls].firstItem;
|
|
}
|
|
|
|
/// \brief Constructor to get invalid iterator
|
|
///
|
|
/// Constructor to get invalid iterator
|
|
ItemIt(Invalid) : extendFind(0), idx(-1) {}
|
|
|
|
/// \brief Increment operator
|
|
///
|
|
/// It steps to the next item in the class.
|
|
ItemIt& operator++() {
|
|
idx = extendFind->items[idx].next;
|
|
if (fdx == idx) idx = -1;
|
|
return *this;
|
|
}
|
|
|
|
/// \brief Conversion operator
|
|
///
|
|
/// It converts the iterator to the current item.
|
|
operator const Item&() const {
|
|
return extendFind->items[idx].item;
|
|
}
|
|
|
|
/// \brief Equality operator
|
|
///
|
|
/// Equality operator
|
|
bool operator==(const ItemIt& i) {
|
|
return i.idx == idx;
|
|
}
|
|
|
|
/// \brief Inequality operator
|
|
///
|
|
/// Inequality operator
|
|
bool operator!=(const ItemIt& i) {
|
|
return i.idx != idx;
|
|
}
|
|
|
|
private:
|
|
const ExtendFindEnum* extendFind;
|
|
int idx, fdx;
|
|
};
|
|
|
|
};
|
|
|
|
/// \ingroup auxdat
|
|
///
|
|
/// \brief A \e Union-Find data structure implementation which
|
|
/// is able to store a priority for each item and retrieve the minimum of
|
|
/// each class.
|
|
///
|
|
/// A \e Union-Find data structure implementation which is able to
|
|
/// store a priority for each item and retrieve the minimum of each
|
|
/// class. In addition, it supports the joining and splitting the
|
|
/// components. If you don't need this feature then you makes
|
|
/// better to use the \ref UnionFind class which is more efficient.
|
|
///
|
|
/// The union-find data strcuture based on a (2, 16)-tree with a
|
|
/// tournament minimum selection on the internal nodes. The insert
|
|
/// operation takes O(1), the find, set, decrease and increase takes
|
|
/// O(log(n)), where n is the number of nodes in the current
|
|
/// component. The complexity of join and split is O(log(n)*k),
|
|
/// where n is the sum of the number of the nodes and k is the
|
|
/// number of joined components or the number of the components
|
|
/// after the split.
|
|
///
|
|
/// \pre You need to add all the elements by the \ref insert()
|
|
/// method.
|
|
template <typename V, typename IM, typename Comp = std::less<V> >
|
|
class HeapUnionFind {
|
|
public:
|
|
|
|
///\e
|
|
typedef V Value;
|
|
///\e
|
|
typedef typename IM::Key Item;
|
|
///\e
|
|
typedef IM ItemIntMap;
|
|
///\e
|
|
typedef Comp Compare;
|
|
|
|
private:
|
|
|
|
static const int cmax = 16;
|
|
|
|
ItemIntMap& index;
|
|
|
|
struct ClassNode {
|
|
int parent;
|
|
int depth;
|
|
|
|
int left, right;
|
|
int next, prev;
|
|
};
|
|
|
|
int first_class;
|
|
int first_free_class;
|
|
std::vector<ClassNode> classes;
|
|
|
|
int newClass() {
|
|
if (first_free_class < 0) {
|
|
int id = classes.size();
|
|
classes.push_back(ClassNode());
|
|
return id;
|
|
} else {
|
|
int id = first_free_class;
|
|
first_free_class = classes[id].next;
|
|
return id;
|
|
}
|
|
}
|
|
|
|
void deleteClass(int id) {
|
|
classes[id].next = first_free_class;
|
|
first_free_class = id;
|
|
}
|
|
|
|
struct ItemNode {
|
|
int parent;
|
|
Item item;
|
|
Value prio;
|
|
int next, prev;
|
|
int left, right;
|
|
int size;
|
|
};
|
|
|
|
int first_free_node;
|
|
std::vector<ItemNode> nodes;
|
|
|
|
int newNode() {
|
|
if (first_free_node < 0) {
|
|
int id = nodes.size();
|
|
nodes.push_back(ItemNode());
|
|
return id;
|
|
} else {
|
|
int id = first_free_node;
|
|
first_free_node = nodes[id].next;
|
|
return id;
|
|
}
|
|
}
|
|
|
|
void deleteNode(int id) {
|
|
nodes[id].next = first_free_node;
|
|
first_free_node = id;
|
|
}
|
|
|
|
Comp comp;
|
|
|
|
int findClass(int id) const {
|
|
int kd = id;
|
|
while (kd >= 0) {
|
|
kd = nodes[kd].parent;
|
|
}
|
|
return ~kd;
|
|
}
|
|
|
|
int leftNode(int id) const {
|
|
int kd = ~(classes[id].parent);
|
|
for (int i = 0; i < classes[id].depth; ++i) {
|
|
kd = nodes[kd].left;
|
|
}
|
|
return kd;
|
|
}
|
|
|
|
int nextNode(int id) const {
|
|
int depth = 0;
|
|
while (id >= 0 && nodes[id].next == -1) {
|
|
id = nodes[id].parent;
|
|
++depth;
|
|
}
|
|
if (id < 0) {
|
|
return -1;
|
|
}
|
|
id = nodes[id].next;
|
|
while (depth--) {
|
|
id = nodes[id].left;
|
|
}
|
|
return id;
|
|
}
|
|
|
|
|
|
void setPrio(int id) {
|
|
int jd = nodes[id].left;
|
|
nodes[id].prio = nodes[jd].prio;
|
|
nodes[id].item = nodes[jd].item;
|
|
jd = nodes[jd].next;
|
|
while (jd != -1) {
|
|
if (comp(nodes[jd].prio, nodes[id].prio)) {
|
|
nodes[id].prio = nodes[jd].prio;
|
|
nodes[id].item = nodes[jd].item;
|
|
}
|
|
jd = nodes[jd].next;
|
|
}
|
|
}
|
|
|
|
void push(int id, int jd) {
|
|
nodes[id].size = 1;
|
|
nodes[id].left = nodes[id].right = jd;
|
|
nodes[jd].next = nodes[jd].prev = -1;
|
|
nodes[jd].parent = id;
|
|
}
|
|
|
|
void pushAfter(int id, int jd) {
|
|
int kd = nodes[id].parent;
|
|
if (nodes[id].next != -1) {
|
|
nodes[nodes[id].next].prev = jd;
|
|
if (kd >= 0) {
|
|
nodes[kd].size += 1;
|
|
}
|
|
} else {
|
|
if (kd >= 0) {
|
|
nodes[kd].right = jd;
|
|
nodes[kd].size += 1;
|
|
}
|
|
}
|
|
nodes[jd].next = nodes[id].next;
|
|
nodes[jd].prev = id;
|
|
nodes[id].next = jd;
|
|
nodes[jd].parent = kd;
|
|
}
|
|
|
|
void pushRight(int id, int jd) {
|
|
nodes[id].size += 1;
|
|
nodes[jd].prev = nodes[id].right;
|
|
nodes[jd].next = -1;
|
|
nodes[nodes[id].right].next = jd;
|
|
nodes[id].right = jd;
|
|
nodes[jd].parent = id;
|
|
}
|
|
|
|
void popRight(int id) {
|
|
nodes[id].size -= 1;
|
|
int jd = nodes[id].right;
|
|
nodes[nodes[jd].prev].next = -1;
|
|
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);
|
|
if (less(jd, nodes[jd].next) ||
|
|
nodes[jd].item == nodes[pd].item) {
|
|
nodes[nodes[jd].next].prio = nodes[jd].prio;
|
|
nodes[nodes[jd].next].item = nodes[jd].item;
|
|
}
|
|
popLeft(pd);
|
|
deleteNode(jd);
|
|
jd = pd;
|
|
} else {
|
|
int ld = nodes[nodes[jd].next].left;
|
|
popLeft(nodes[jd].next);
|
|
pushRight(jd, ld);
|
|
if (less(ld, nodes[jd].left) ||
|
|
nodes[ld].item == nodes[pd].item) {
|
|
nodes[jd].item = nodes[ld].item;
|
|
nodes[jd].prio = nodes[ld].prio;
|
|
}
|
|
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);
|
|
if (less(jd, nodes[jd].prev) ||
|
|
nodes[jd].item == nodes[pd].item) {
|
|
nodes[nodes[jd].prev].prio = nodes[jd].prio;
|
|
nodes[nodes[jd].prev].item = nodes[jd].item;
|
|
}
|
|
popRight(pd);
|
|
deleteNode(jd);
|
|
jd = pd;
|
|
} else {
|
|
int ld = nodes[nodes[jd].prev].right;
|
|
popRight(nodes[jd].prev);
|
|
pushLeft(jd, ld);
|
|
if (less(ld, nodes[jd].right) ||
|
|
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 Clears the union-find data structure
|
|
///
|
|
/// Erase each item from the data structure.
|
|
void clear() {
|
|
nodes.clear();
|
|
classes.clear();
|
|
first_free_node = first_free_class = first_class = -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]);
|
|
}
|
|
|
|
/// \brief Joins the classes.
|
|
///
|
|
/// The current function joins the given classes. The parameter is
|
|
/// 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));
|
|
|
|
if (less(~classes[r].parent, right_id)) {
|
|
nodes[new_id].item = nodes[~classes[r].parent].item;
|
|
nodes[new_id].prio = nodes[~classes[r].parent].prio;
|
|
} else {
|
|
nodes[new_id].item = nodes[right_id].item;
|
|
nodes[new_id].prio = nodes[right_id].prio;
|
|
}
|
|
|
|
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));
|
|
|
|
if (less(~classes[l].parent, left_id)) {
|
|
nodes[new_id].item = nodes[~classes[l].parent].item;
|
|
nodes[new_id].prio = nodes[~classes[l].parent].prio;
|
|
} else {
|
|
nodes[new_id].item = nodes[left_id].item;
|
|
nodes[new_id].prio = nodes[left_id].prio;
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
return class_id;
|
|
}
|
|
|
|
/// \brief Split the class to subclasses.
|
|
///
|
|
/// The current function splits the given class. The join, which
|
|
/// made the current class, stored a reference to the
|
|
/// subclasses. The \c splitClass() member restores the classes
|
|
/// and creates the heaps. The parameter is an STL output iterator
|
|
/// which will be filled with the subclass ids. The time
|
|
/// complexity is O(log(n)*k) where n is the overall number of
|
|
/// nodes in the splitted classes and k is the number of the
|
|
/// classes.
|
|
template <typename Iterator>
|
|
void split(int cls, Iterator out) {
|
|
std::vector<int> cs;
|
|
{ // splitting union-find
|
|
int id = cls;
|
|
int l = classes[id].left;
|
|
|
|
classes[l].parent = classes[id].parent;
|
|
classes[l].depth = classes[id].depth;
|
|
|
|
nodes[~(classes[l].parent)].parent = ~l;
|
|
|
|
*out++ = l;
|
|
|
|
while (l != -1) {
|
|
cs.push_back(l);
|
|
l = classes[l].next;
|
|
}
|
|
|
|
classes[classes[id].right].next = first_class;
|
|
classes[first_class].prev = classes[id].right;
|
|
first_class = classes[id].left;
|
|
|
|
if (classes[id].next != -1) {
|
|
classes[classes[id].next].prev = classes[id].prev;
|
|
}
|
|
classes[classes[id].prev].next = classes[id].next;
|
|
|
|
deleteClass(id);
|
|
}
|
|
|
|
{
|
|
for (int i = 1; i < int(cs.size()); ++i) {
|
|
int l = classes[cs[i]].depth;
|
|
while (nodes[nodes[l].parent].left == l) {
|
|
l = nodes[l].parent;
|
|
}
|
|
int r = l;
|
|
while (nodes[l].parent >= 0) {
|
|
l = nodes[l].parent;
|
|
int new_node = newNode();
|
|
|
|
nodes[new_node].prev = -1;
|
|
nodes[new_node].next = -1;
|
|
|
|
split(r, new_node);
|
|
pushAfter(l, new_node);
|
|
setPrio(l);
|
|
setPrio(new_node);
|
|
r = new_node;
|
|
}
|
|
classes[cs[i]].parent = ~r;
|
|
classes[cs[i]].depth = classes[~(nodes[l].parent)].depth;
|
|
nodes[r].parent = ~cs[i];
|
|
|
|
nodes[l].next = -1;
|
|
nodes[r].prev = -1;
|
|
|
|
repairRight(~(nodes[l].parent));
|
|
repairLeft(cs[i]);
|
|
|
|
*out++ = cs[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
/// \brief Gives back the priority of the current item.
|
|
///
|
|
/// Gives back the priority of the current item.
|
|
const Value& operator[](const Item& item) const {
|
|
return nodes[index[item]].prio;
|
|
}
|
|
|
|
/// \brief Sets the priority of the current item.
|
|
///
|
|
/// Sets the priority of the current item.
|
|
void set(const Item& item, const Value& prio) {
|
|
if (comp(prio, nodes[index[item]].prio)) {
|
|
decrease(item, prio);
|
|
} else if (!comp(prio, nodes[index[item]].prio)) {
|
|
increase(item, prio);
|
|
}
|
|
}
|
|
|
|
/// \brief Increase the priority of the current item.
|
|
///
|
|
/// Increase the priority of the current item.
|
|
void increase(const Item& item, const Value& prio) {
|
|
int id = index[item];
|
|
int kd = nodes[id].parent;
|
|
nodes[id].prio = prio;
|
|
while (kd >= 0 && nodes[kd].item == item) {
|
|
setPrio(kd);
|
|
kd = nodes[kd].parent;
|
|
}
|
|
}
|
|
|
|
/// \brief Increase the priority of the current item.
|
|
///
|
|
/// Increase the priority of the current item.
|
|
void decrease(const Item& item, const Value& prio) {
|
|
int id = index[item];
|
|
int kd = nodes[id].parent;
|
|
nodes[id].prio = prio;
|
|
while (kd >= 0 && less(id, kd)) {
|
|
nodes[kd].prio = prio;
|
|
nodes[kd].item = item;
|
|
kd = nodes[kd].parent;
|
|
}
|
|
}
|
|
|
|
/// \brief Gives back the minimum priority of the class.
|
|
///
|
|
/// Gives back the minimum priority of the class.
|
|
const Value& classPrio(int cls) const {
|
|
return nodes[~(classes[cls].parent)].prio;
|
|
}
|
|
|
|
/// \brief Gives back the minimum priority item of the class.
|
|
///
|
|
/// \return Gives back the minimum priority item of the class.
|
|
const Item& classTop(int cls) const {
|
|
return nodes[~(classes[cls].parent)].item;
|
|
}
|
|
|
|
/// \brief Gives back a representant item of the class.
|
|
///
|
|
/// Gives back a representant item of the class.
|
|
/// The representant is indpendent from the priorities of the
|
|
/// items.
|
|
const Item& classRep(int id) const {
|
|
int parent = classes[id].parent;
|
|
return nodes[parent >= 0 ? classes[id].depth : leftNode(id)].item;
|
|
}
|
|
|
|
/// \brief LEMON style iterator for the items of a class.
|
|
///
|
|
/// ClassIt is a lemon style iterator for the components. It iterates
|
|
/// on the items of a class. By example if you want to iterate on
|
|
/// each items of each classes then you may write the next code.
|
|
///\code
|
|
/// for (ClassIt cit(huf); cit != INVALID; ++cit) {
|
|
/// std::cout << "Class: ";
|
|
/// for (ItemIt iit(huf, cit); iit != INVALID; ++iit) {
|
|
/// std::cout << toString(iit) << ' ' << std::endl;
|
|
/// }
|
|
/// std::cout << std::endl;
|
|
/// }
|
|
///\endcode
|
|
class ItemIt {
|
|
private:
|
|
|
|
const HeapUnionFind* _huf;
|
|
int _id, _lid;
|
|
|
|
public:
|
|
|
|
/// \brief Default constructor
|
|
///
|
|
/// Default constructor
|
|
ItemIt() {}
|
|
|
|
ItemIt(const HeapUnionFind& huf, int cls) : _huf(&huf) {
|
|
int id = cls;
|
|
int parent = _huf->classes[id].parent;
|
|
if (parent >= 0) {
|
|
_id = _huf->classes[id].depth;
|
|
if (_huf->classes[id].next != -1) {
|
|
_lid = _huf->classes[_huf->classes[id].next].depth;
|
|
} else {
|
|
_lid = -1;
|
|
}
|
|
} else {
|
|
_id = _huf->leftNode(id);
|
|
_lid = -1;
|
|
}
|
|
}
|
|
|
|
/// \brief Increment operator
|
|
///
|
|
/// It steps to the next item in the class.
|
|
ItemIt& operator++() {
|
|
_id = _huf->nextNode(_id);
|
|
return *this;
|
|
}
|
|
|
|
/// \brief Conversion operator
|
|
///
|
|
/// It converts the iterator to the current item.
|
|
operator const Item&() const {
|
|
return _huf->nodes[_id].item;
|
|
}
|
|
|
|
/// \brief Equality operator
|
|
///
|
|
/// Equality operator
|
|
bool operator==(const ItemIt& i) {
|
|
return i._id == _id;
|
|
}
|
|
|
|
/// \brief Inequality operator
|
|
///
|
|
/// Inequality operator
|
|
bool operator!=(const ItemIt& i) {
|
|
return i._id != _id;
|
|
}
|
|
|
|
/// \brief Equality operator
|
|
///
|
|
/// Equality operator
|
|
bool operator==(Invalid) {
|
|
return _id == _lid;
|
|
}
|
|
|
|
/// \brief Inequality operator
|
|
///
|
|
/// Inequality operator
|
|
bool operator!=(Invalid) {
|
|
return _id != _lid;
|
|
}
|
|
|
|
};
|
|
|
|
/// \brief Class iterator
|
|
///
|
|
/// The iterator stores
|
|
class ClassIt {
|
|
private:
|
|
|
|
const HeapUnionFind* _huf;
|
|
int _id;
|
|
|
|
public:
|
|
|
|
ClassIt(const HeapUnionFind& huf)
|
|
: _huf(&huf), _id(huf.first_class) {}
|
|
|
|
ClassIt(const HeapUnionFind& huf, int cls)
|
|
: _huf(&huf), _id(huf.classes[cls].left) {}
|
|
|
|
ClassIt(Invalid) : _huf(0), _id(-1) {}
|
|
|
|
const ClassIt& operator++() {
|
|
_id = _huf->classes[_id].next;
|
|
return *this;
|
|
}
|
|
|
|
/// \brief Equality operator
|
|
///
|
|
/// Equality operator
|
|
bool operator==(const ClassIt& i) {
|
|
return i._id == _id;
|
|
}
|
|
|
|
/// \brief Inequality operator
|
|
///
|
|
/// Inequality operator
|
|
bool operator!=(const ClassIt& i) {
|
|
return i._id != _id;
|
|
}
|
|
|
|
operator int() const {
|
|
return _id;
|
|
}
|
|
|
|
};
|
|
|
|
};
|
|
|
|
//! @}
|
|
|
|
} //namespace lemon
|
|
|
|
#endif //LEMON_UNION_FIND_H
|