Changeset 394:3a34c5626e52 in lemon-0.x for src/work

Timestamp:

04/24/04 18:03:25 (20 years ago)

Author:

beckerjc

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@525

Message:

New union-find structure with enumerable classes.

Location:

src/work/johanna

Files:

• Makefile (modified) (1 diff)
• contract_wrapper.h (added)
• kruskal.h (modified) (1 diff)
• unionfind.h (modified) (5 diffs)
• unionfind_test.cc (added)

src/work/johanna/Makefile

@@ -1 @@
-BINARIES = kruskal_test ma_order_test
+BINARIES = kruskal_test ma_order_test unionfind_test
 INCLUDEDIRS= -I. -I.. -I../../include -I../{marci,jacint,alpar,klao,akos}
 include ../makefile

src/work/johanna/kruskal.h

@@ -26 +26 @@
     for (typename InputEdgeOrder::const_iterator p = edges.begin(); 
          p!=edges.end(); ++p ) {
-      if ( uf.joinComponents(G.head(edges.first(p)),
+      if ( uf.join(G.head(edges.first(p)),
                              G.tail(edges.first(p))) ) {
         out_map.set(edges.first(p), true);

src/work/johanna/unionfind.h

@@ -4 +4 @@
 
 #include <vector>
+#include <list>
 #include <utility>
+#include <algorithm>
+
+#include <invalid.h>
 
 namespace hugo {
@@ -23 +27 @@
 
 
-    int whichComponent(T a)
+    int find(T a)
     {
       int comp0 = map[a];
       if (comp0 < 0) {
-        return insertNewElement(a);
+        return insert(a);
       }
       int comp = comp0;
@@ -42 +46 @@
     }
 
-    int insertNewElement(T a)
+    int insert(T a)
     {
       int n = data.size();
-      data.push_back(make_pair(n, 1));
+      data.push_back(std::make_pair(n, 1));
       map.set(a,n);
       return n;
     }
 
-    bool joinComponents(T a, T b)
-    {
-      int ca = whichComponent(a);
-      int cb = whichComponent(b);
+    bool join(T a, T b)
+    {
+      int ca = find(a);
+      int cb = find(b);
 
       if ( ca == cb ) 
@@ -69 +73 @@
     }
 
-    int componentSize(T a)
-    {
-      int ca = whichComponent(a);
+    int size(T a)
+    {
+      int ca = find(a);
       return data[ca].second;
     }
@@ -77 +81 @@
   };
 
+
+
+
+  /*******************************************************/
+
+
+
+  template <typename T>
+  struct UnionFindEnumItem {
+
+    typedef std::list<UnionFindEnumItem> ItemList;
+    typedef std::list<ItemList> ClassList;
+    typedef typename ItemList::iterator IIter;
+    typedef typename ClassList::iterator CIter;
+
+    T me;
+    IIter parent;
+    int size;
+    CIter my_class;
+
+    UnionFindEnumItem() {}
+    UnionFindEnumItem(const T &_me, CIter _my_class): 
+      me(_me), size(1), my_class(_my_class) {}
+  };
+
+  template <typename T, template <typename Item> class Map>
+  class UnionFindEnum {
+
+    typedef std::list<UnionFindEnumItem<T> > ItemList;
+    typedef std::list<ItemList> ClassList;
+    typedef typename ItemList::iterator IIter;
+    typedef typename ItemList::const_iterator IcIter;
+    typedef typename ClassList::iterator CIter;
+    typedef typename ClassList::const_iterator CcIter;
+
+  public:
+    typedef T ElementType;
+    typedef UnionFindEnumItem<T> ItemType;
+    typedef Map< IIter > MapType;
+
+  private:
+    MapType& m;
+    ClassList classes;
+
+    //    IIter where(const T &a) { return m[a]; }
+    //    IIter parent(IIter a) { return a->parent; }
+    //    P sibling(P a) { return &m[a->sibling]; }
+
+    IIter _find(IIter a) const {
+      IIter comp = a;
+      IIter next;
+      while( (next = comp->parent) != comp ) {
+        comp = next;
+      }
+
+      IIter comp1 = a;
+      while( (next = comp1->parent) != comp ) {
+        comp1->parent = comp->parent;
+        comp1 = next;
+      }
+      return comp;
+    }
+
+  public:
+    UnionFindEnum(MapType& _m) : m(_m) {}
+
+    void insert(const T &a)
+    {
+
+
+      classes.push_back(ItemList());
+      CIter aclass = classes.end();
+      --aclass;
+
+      ItemList &alist = *aclass;
+      alist.push_back(ItemType(a, aclass));
+      IIter ai = alist.begin();
+
+      ai->parent = ai;
+      m.set(a, ai);
+
+    }
+
+    T find(const T &a) const {
+      return _find(m[a])->me;
+    }
+
+    bool join(T a, T b) {
+
+      IIter ca = _find(m[a]);
+      IIter cb = _find(m[b]);
+
+      if ( ca == cb ) {
+        return false;
+      }
+
+      if ( ca->size > cb->size ) {
+
+        cb->parent = ca->parent;
+        ca->size += cb->size;
+        
+        ItemList &alist = *ca->my_class;
+        alist.splice(alist.end(),*cb->my_class);
+
+        classes.erase(cb->my_class);
+        cb->my_class = 0;
+      }
+      else {
+
+        ca->parent = cb->parent;
+        cb->size += ca->size;
+        
+        ItemList &blist = *cb->my_class;
+        blist.splice(blist.end(),*ca->my_class);
+
+        classes.erase(ca->my_class);
+        ca->my_class = 0;
+      }
+
+      return true;
+    }
+
+    int size(const T &a) const {
+      return _find(m[a])->size;
+    }
+
+    
+    void split(const T &a) {
+
+      IIter ca = _find(m[a]);
+ 
+      if ( ca->size == 1 )
+        return;
+      
+      CIter aclass = ca->my_class;
+
+      for(IIter curr = ca; ++curr != aclass->end(); curr=ca) {
+        classes.push_back(ItemList());
+        CIter nl = --classes.end();
+        nl->splice(nl->end(), *aclass, curr);
+
+        curr->size=1;
+        curr->parent=curr;
+        curr->my_class = nl;
+      }
+
+      ca->size=1;
+      return;
+    }
+
+    void erase(const T &a) {
+
+      IIter ma = m[a];
+      if (ma == 0) return;
+
+      IIter la = _find(ma);
+      if (la == ma) {
+        if (ma -> size == 1){
+          classes.erase(ma->my_class);
+          m.set(a,0);
+          return;
+        }
+        ++la;
+        la->size = ma->size - 1; 
+        la->my_class = ma->my_class;    
+      }
+
+      for (IIter i = la; i != la->my_class->end(); ++i) {
+        i->parent = la;
+      }
+
+      la->my_class->erase(ma);
+      m.set(a,0);
+    }
+
+    void eraseClass(const T &a) {
+      IIter ma = m[a];
+      if (ma == 0) return;
+#     ifdef DEBUG
+      CIter c = _find(ma)->my_class;
+      for (IIter i=c->begin(); i!=c->end(); ++i)
+        m.set(i->me, 0);
+#     endif
+      classes.erase(_find(ma)->my_class);
+    }
+
+
+    class ClassIt {
+      friend class UnionFindEnum;
+
+      CcIter i;
+    public:
+      ClassIt(Invalid): i(0) {}
+      ClassIt() {}
+      
+      operator const T& () const { 
+        ItemList const &ll = *i;
+        return (ll.begin())->me; }
+      bool operator == (ClassIt it) const {
+        return (i == it.i);
+      }
+      bool operator != (ClassIt it) const {
+        return (i != it.i);
+      }
+      bool operator < (ClassIt it) const {
+        return (i < it.i);
+      }
+
+      bool valid() const { return i != 0; }
+    private:
+      void first(const ClassList &l) { i = l.begin(); validate(l); }
+      void next(const ClassList &l) {
+        ++i; 
+        validate(l);
+      }
+      void validate(const ClassList &l) {
+        if ( i == l.end() ) 
+          i = 0;
+      }
+    };
+
+
+    ClassIt& first(ClassIt& it) const {
+      it.first(classes);
+      return it;
+    }
+
+    bool valid(ClassIt const &it) const {
+      return it.valid(); 
+    }
+
+    ClassIt& next(ClassIt& it) const {
+      it.next(classes);
+      return it;
+    }
+
+
+    class ItemIt {
+      friend class UnionFindEnum;
+
+      IcIter i;
+      const ItemList *l;
+    public:
+      ItemIt(Invalid): i(0) {}
+      ItemIt() {}
+      
+      operator const T& () const { return i->me; }
+      bool operator == (ItemIt it) const {
+        return (i == it.i);
+      }
+      bool operator != (ItemIt it) const {
+        return (i != it.i);
+      }
+      bool operator < (ItemIt it) const {
+        return (i < it.i);
+      }
+
+      bool valid() const { return i != 0; }
+    private:
+      void first(const ItemList &il) { l=&il; i = l->begin(); validate(); }
+      void next() {
+        ++i; 
+        validate();
+      }
+      void validate() {
+        if ( i == l->end() ) 
+          i = 0;
+      }
+    };
+
+
+    ItemIt& first(ItemIt& it, const T& a) const {
+      it.first( * _find(m[a])->my_class );
+      return it;
+    }
+
+    bool valid(ItemIt const &it) const {
+      return it.valid(); 
+    }
+
+    ItemIt& next(ItemIt& it) const {
+      it.next();
+      return it;
+    }
+    
+
+
+  };
+
 } //namespace hugo