Java UnionFind類代碼示例

import jpaul.DataStructs.UnionFind; //導入依賴的package包/類
private Collection<Constraint<V,Info>> unifyEquals(Collection<Constraint<V,Info>> cs) {
cs = new LinkedList<Constraint<V,Info>>(cs);
uf = new UnionFind<V>();
unifyMutuallySmaller(cs);
boolean changed = true;
while(changed) {
    changed = unifySingleLt(cs, false);
    if(DEBUG) unifySingleLt(cs, true);
    if(eliminateEmpty(cs)) {
	changed = true;
    }
    if(changed) {
	cs = updateConstraints(cs);
    }
}

int nbDisjointVars = 0;
for(V v : vars()) {
    V parent = uf.find(v);
    if(v == parent) nbDisjointVars++;
}
vertexHashCapacity = (3 * nbDisjointVars) / 2;

return cs;
   }
 

import jpaul.DataStructs.UnionFind; //導入依賴的package包/類
public Constraint<V,Info> rewrite(UnionFind<V> uf) {
V vs2 = uf.find(vs);
V vd2 = uf.find(vd);
// remove superfluous constraints
if(vs2.equals(vd2)) return null;
// nothing changed, so why generate a new constraint ?
if(vs.equals(vs2) && vd.equals(vd2)) return this;
return new LtConstraint<V,Info>(vs2, vd2);
   }
 

import jpaul.DataStructs.UnionFind; //導入依賴的package包/類
/** We implemented {@link #rewrite}, {@link #equals}, and {@link
       #hashCode}, such that constraints that are identical after
       variable unification are not duplicated needlessly. */
   public Constraint<SVar<T>,Set<T>> rewrite(UnionFind<SVar<T>> uf) {
SVar<T> vIn1_p  = uf.find(vIn1);
SVar<T> vIn2_p  = uf.find(vIn2);
SVar<T> vDest_p = uf.find(vDest);	
return new IntersectConstraint<T>(vIn1_p, vIn2_p, vDest_p);
   }
 

import jpaul.DataStructs.UnionFind; //導入依賴的package包/類
/** We implemented {@link #rewrite}, {@link #equals}, and {@link
       #hashCode}, such that constraints that are identical after
       variable unification are not duplicated needlessly. */
   public Constraint<SVar<T>,Set<T>> rewrite(UnionFind<SVar<T>> uf) {
SVar<T> vIn1_p  = uf.find(vIn1);
SVar<T> vIn2_p  = uf.find(vIn2);
SVar<T> vDest_p = uf.find(vDest);	
return new IntersectConstraint(vIn1_p, vIn2_p, vDest_p);
   }
 

import jpaul.DataStructs.UnionFind; //導入依賴的package包/類
public Constraint<V,Info> rewrite(UnionFind<V> uf) {
V vd2 = uf.find(vd);
// nothing changed, so why generate a new constraint ?
if(vd.equals(vd2)) return this;
return new CtConstraint<V,Info>(ct, vd2);
   }
 

import jpaul.DataStructs.UnionFind; //導入依賴的package包/類
/** We implemented {@link #rewrite}, {@link #equals}, and {@link
       #hashCode}, such that constraints that are identical after
       variable unification are not duplicated needlessly. */
   public Constraint<SVar<T>,Set<T>> rewrite(UnionFind<SVar<T>> uf) {
SVar<T> vIn_p   = uf.find(vIn);
SVar<T> vDest_p = uf.find(vDest);	
return new CtDiffConstraint<T>(vIn_p, ctSet, vDest_p);
   }
 

import jpaul.DataStructs.UnionFind; //導入依賴的package包/類
/** Rewrites <code>this</code> constraint by replacing each
variable with the representative of its equivalence class.
The real implementation of this method is optional: the
default implementation returns <code>this</code> constraint,
unmodified.  This is safe: the constraint writer does not need
to be aware of variable unification, as the
<code>SolAccessor</code> passed by the constraint solver
already deals with it.

<p>Implementing <code>rewrite</code> may be useful when
unification causes several constraints to become identical:
e.g., consider <code>v1 &lt;= v2</code> and <code>v3 &lt;=
v4</code>, after we unify <code>v1</code> with <code>v3</code>
and <code>v2</code> with <code>v4</code>.  Implementing
<code>rewrite</code>, <code>equals</code> (and
<code>hashCode</code>) allows the solver to avoid working with
several identical constraints.

@param uf Union-find structure; for each variable
<code>v</code>, <code>uf.find(v)</code> is the representative
of its equivalence class. */
   public Constraint<V,Info> rewrite(UnionFind<V> uf) {
return this;
   }