public void addEdge(Edge e)
{
int v = e.either;
int w = e.other(v);
adj[v].Add(e);
adj[w].Add(e);
_E++;
}
public BoruvkaMST(EdgeWeightedGraph ewg)
{
this.mst = new Bag();
UF uF = new UF(ewg.V());
int num = 1;
while (num < ewg.V() && this.mst.size() < ewg.V() - 1)
{
Edge[] array = new Edge[ewg.V()];
Iterator iterator = ewg.edges().iterator();
while (iterator.hasNext())
{
Edge edge = (Edge)iterator.next();
int num2 = edge.either();
int num3 = edge.other(num2);
int num4 = uF.find(num2);
int num5 = uF.find(num3);
if (num4 != num5)
{
if (array[num4] == null || BoruvkaMST.less(edge, array[num4]))
{
array[num4] = edge;
}
if (array[num5] == null || BoruvkaMST.less(edge, array[num5]))
{
array[num5] = edge;
}
}
}
for (int i = 0; i < ewg.V(); i++)
{
Edge edge = array[i];
if (edge != null)
{
int num2 = edge.either();
int num3 = edge.other(num2);
if (!uF.connected(num2, num3))
{
this.mst.add(edge);
this.weight += edge.weight();
uF.union(num2, num3);
}
}
}
num += num;
}
if (!BoruvkaMST.s_assertionsDisabled && !this.check(ewg))
{
throw new AssertionError();
}
}
private double weight; // weight of MST
public BoruvkaMST(EdgeWeightedGraph G)
{
UF uf = new UF(G.V());
// repeat at most log V times or until we have V-1 edges
for (int t = 1; t < G.V() && mst.size() < G.V() - 1; t = t + t)
{
// foreach tree in forest, find closest edge
// if edge weights are equal, ties are broken in favor of first edge in G.edges()
Edge[] closest = new Edge[G.V()];
foreach (Edge e in G.edges())
{
int v = e.either(), w = e.other(v);
int i = uf.find(v), j = uf.find(w);
if (i == j)
{
continue; // same tree
}
if (closest[i] == null || less(e, closest[i]))
{
closest[i] = e;
}
if (closest[j] == null || less(e, closest[j]))
{
closest[j] = e;
}
}
// add newly discovered edges to MST
for (int i = 0; i < G.V(); i++)
{
Edge e = closest[i];
if (e != null)
{
int v = e.either(), w = e.other(v);
// don't add the same edge twice
if (!uf.connected(v, w))
{
mst.Add(e);
weight += e.Weight();
uf.union(v, w);
}
}
}
}
}
private void scan(EdgeWeightedGraph edgeWeightedGraph, int num)
{
if (!LazyPrimMST.s_assertionsDisabled && this.marked[num])
{
throw new AssertionError();
}
this.marked[num] = true;
Iterator iterator = edgeWeightedGraph.adj(num).iterator();
while (iterator.hasNext())
{
Edge edge = (Edge)iterator.next();
if (!this.marked[edge.other(num)])
{
this.pq.insert(edge);
}
}
}
private void prim(EdgeWeightedGraph G, int s)
{
scan(G, s);
while (!pq.isEmpty())
{ // better to stop when mst has V-1 edges
Edge e = pq.delMin(); // smallest edge on pq
int v = e.either(), w = e.other(v); // two endpoints
if (marked[v] && marked[w])
{
continue; // lazy, both v and w already scanned
}
mst.Enqueue(e); // add e to MST
weight += e.Weight();
if (!marked[v])
{
scan(G, v); // v becomes part of tree
}
if (!marked[w])
{
scan(G, w); // w becomes part of tree
}
}
}
private bool check(EdgeWeightedGraph edgeWeightedGraph)
{
double num = (double)0f;
Iterator iterator = this.edges().iterator();
while (iterator.hasNext())
{
Edge edge = (Edge)iterator.next();
num += edge.weight();
}
double num2 = 1E-12;
if (java.lang.Math.abs(num - this.weight()) > num2)
{
System.err.printf("Weight of edges does not equal weight(): %f vs. %f\n", new object[]
{
java.lang.Double.valueOf(num),
java.lang.Double.valueOf(this.weight())
});
return false;
}
UF uF = new UF(edgeWeightedGraph.V());
Iterator iterator2 = this.edges().iterator();
while (iterator2.hasNext())
{
Edge edge2 = (Edge)iterator2.next();
int num3 = edge2.either();
int i = edge2.other(num3);
if (uF.connected(num3, i))
{
System.err.println("Not a forest");
return false;
}
uF.union(num3, i);
}
iterator2 = edgeWeightedGraph.edges().iterator();
while (iterator2.hasNext())
{
Edge edge2 = (Edge)iterator2.next();
int num3 = edge2.either();
int i = edge2.other(num3);
if (!uF.connected(num3, i))
{
System.err.println("Not a spanning forest");
return false;
}
}
iterator2 = this.edges().iterator();
while (iterator2.hasNext())
{
Edge edge2 = (Edge)iterator2.next();
uF = new UF(edgeWeightedGraph.V());
Iterator iterator3 = this.edges().iterator();
while (iterator3.hasNext())
{
Edge edge3 = (Edge)iterator3.next();
int num4 = edge3.either();
int i2 = edge3.other(num4);
if (edge3 != edge2)
{
uF.union(num4, i2);
}
}
iterator3 = edgeWeightedGraph.edges().iterator();
while (iterator3.hasNext())
{
Edge edge3 = (Edge)iterator3.next();
int num4 = edge3.either();
int i2 = edge3.other(num4);
if (!uF.connected(num4, i2) && edge3.weight() < edge2.weight())
{
System.err.println(new StringBuilder().append("Edge ").append(edge3).append(" violates cut optimality conditions").toString());
return false;
}
}
}
return true;
}
