public static void Main()
{
DisjointSet ds = new DisjointSet();
ds.makeSet(1);
ds.makeSet(2);
ds.makeSet(3);
ds.makeSet(4);
ds.makeSet(5);
ds.makeSet(6);
ds.makeSet(7);
ds.union(1, 2);
ds.union(2, 3);
ds.union(4, 5);
ds.union(6, 7);
ds.union(5, 6);
ds.union(3, 7);
Console.WriteLine(ds.findSet(1));
Console.WriteLine(ds.findSet(2));
Console.WriteLine(ds.findSet(3));
Console.WriteLine(ds.findSet(4));
Console.WriteLine(ds.findSet(5));
Console.WriteLine(ds.findSet(6));
Console.WriteLine(ds.findSet(7));
}
public void Compute()
{
// clear previous results
SpanningTreeEdges.Clear();
// create disjoint set object
// fill in disjoint sets
DisjointSet dset = new DisjointSet(VisitedGraph.Vertices);
// create and fill in priority queue
PriorityQueue Q = new PriorityQueue(Weights, VisitedGraph.Edges);
// iterate over edges
while (Q.Count != 0)
{
IEdge e = Q.Peek();
Q.Pop();
IVertex u = dset.FindSet(e.Source);
IVertex v = dset.FindSet(e.Target);
if (u != v)
{
SpanningTreeEdges.Add(e);
dset.Link(u, v);
}
}
}
public void Disjoint_Set()
{
char result;
Console.Write("testing Disjoint sets.");
List <char> elementCollection = new List <char>()
{
'A', 'B', 'C', 'D', 'E'
};
DisjointSet <char> disjointSet = new DisjointSet <char>(elementCollection);
char itemtoSearch = 'D';
result = disjointSet.Find(itemtoSearch);
Console.WriteLine(string.Format("The searched item {0} is associated with Disjoint Set {1}", itemtoSearch, result));
disjointSet.Union('D', 'A'); // Sets A is a parent element of item D. Now, A and D will be in the same Set.
result = disjointSet.Find(itemtoSearch);
Console.WriteLine(string.Format("The searched item {0} is associated with Disjoint Set {1}", itemtoSearch, result));
disjointSet.Union('A', 'B'); // Sets B is a parent element of item A. Now, A, B and D will be in the same Set.
result = disjointSet.Find(itemtoSearch);
Console.WriteLine(string.Format("The searched item {0} is associated with Disjoint Set {1}", itemtoSearch, result));
}
public ICollection <IGraphEdge <T> > MinimumSpanningTree(IGraph <T> graph)
{
DisjointSet <IGraphNode <T> > nodes = new DisjointSet <IGraphNode <T> >();
foreach (IGraphNode <T> node in graph.Nodes)
{
nodes.Add(node);
}
PriorityQueue <QueueType> edges = new PriorityQueue <QueueType>(graph.EdgeCount);
foreach (IGraphEdge <T> edge in graph.Edges)
{
edges.Add(new QueueType(edge.weight, edge));
}
List <IGraphEdge <T> > ret = new List <IGraphEdge <T> >(graph.NodeCount);
while (edges.Count > 0)
{
IGraphEdge <T> edge = edges.Pop().Second;
if (nodes.AreUnited(edge.node1, edge.node2))
{
continue;
}
ret.Add(edge);
nodes.Union(edge.node1, edge.node2);
}
return(ret);
}
public void Union(int size)
{
var pairs = GenerateRandomPairs(size);
IDisjointSet actual = new DisjointSet(size);
IDisjointSet expected = new NaiveDisjointSet(size);
foreach (var pair in pairs)
{
expected.Union(pair.Item1, pair.Item2);
actual.Union(pair.Item1, pair.Item2);
var expectedSets = expected.GetSets();
var actualSets = actual.GetSets();
Assert.Equal(expectedSets.Length, actualSets.Length);
foreach (var expectedSet in expectedSets)
{
var actualSet = actualSets.FirstOrDefault(x => x.Contains(expectedSet[0]));
Assert.Equal(expectedSet.Length, actualSet.Length);
Assert.True(expectedSet.All(x => actualSet.Contains(x)));
}
Assert.Equal(expected.SetCount, actual.SetCount);
for (int i = 0; i < size; i++)
{
Assert.Equal(expected.GetSetSize(i), actual.GetSetSize(i));
for (int j = 0; j < size; j++)
{
Assert.Equal(expected.InSameSet(i, j), actual.InSameSet(i, j));
}
}
}
}
static void Main(string[] args)
{
string[] primeraLinea = Console.ReadLine().Split();
string[] edades = Console.ReadLine().Split();
int acciones = int.Parse(primeraLinea[1]);
DisjointSet myDisjointSet = new DisjointSet(edades);
LinkedList <double> respuestaAcciones = new LinkedList <double>();
for (int veces = 0; veces < acciones; veces++)
{
string[] accion = Console.ReadLine().Split();
if (accion[0].Equals("2"))
{
respuestaAcciones.AddLast(myDisjointSet.Promedio(int.Parse(accion[1]) - 1));
}
else if (accion[0].Equals("1"))
{
myDisjointSet.Merge(int.Parse(accion[1]) - 1, int.Parse(accion[2]) - 1);
}
}
foreach (var el in respuestaAcciones)
{
Console.WriteLine("{0:f2}", el, 2);
}
}
public void Basic()
{
var set = new DisjointSet <int>();
set.Clear();
foreach (int v in Enumerable.Range(1, 9))
{
set.Add(v);
}
foreach (int x in Enumerable.Range(1, 9))
{
foreach (int y in Enumerable.Range(1, 9))
{
Assert.IsFalse(x != y && set.IsUnited(x, y));
}
}
set.Unite(1, 9);
Assert.AreEqual(set.Count, 8);
Assert.IsTrue(set.IsUnited(1, 9));
set.Unite(2, 7);
Assert.AreEqual(set.Count, 7);
Assert.AreEqual(set.ElementCount, 9);
set.Unite(7, 1);
Assert.IsTrue(set.IsUnited(2, 9));
Assert.IsFalse(set.IsUnited(2, 6));
Assert.AreEqual(set.Count, 6);
Assert.AreEqual(set.ElementCount, 9);
}
public void Find_Should_FindSelf_When_SetEmpty(int size, int i)
{
DisjointSet disjointSet = new DisjointSet(size);
int actual = disjointSet.Find(i);
Assert.Equal(i, actual);
}
public void DisjointSetFindGuardCase2Test()
{
DisjointSet <int> disjointSet = new DisjointSet <int>();
disjointSet.MakeSet(1);
var result = disjointSet.Find(2);
}
public void DisjointSetPathCompressionTest()
{
DisjointSet <int> disjointSet = new DisjointSet <int>();
disjointSet.MakeSet(1);
disjointSet.MakeSet(2);
disjointSet.MakeSet(3);
disjointSet.MakeSet(4);
disjointSet.MakeSet(5);
disjointSet.MakeSet(6);
disjointSet.MakeSet(7);
disjointSet.MakeSet(8);
disjointSet.Union(1, 2);
disjointSet.Union(3, 4);
disjointSet.Union(5, 6);
disjointSet.Union(7, 8);
disjointSet.Union(1, 3);
disjointSet.Union(5, 7);
disjointSet.Union(1, 5);
List <int> parentList = disjointSet.GetPath(8);
CollectionAssert.AreEqual(new int[] { 7, 5, 1 }, parentList);
var setId = disjointSet.Find(8);
Assert.AreEqual(1, disjointSet.GetItemCore(8).Parent);
Assert.AreEqual(1, disjointSet.GetItemCore(7).Parent);
Assert.AreEqual(1, disjointSet.GetItemCore(5).Parent);
}
public void DisjointSetMakeSetGuardCase3Test()
{
DisjointSet <int> disjointSet = new DisjointSet <int>();
disjointSet.MakeSet(1);
disjointSet.MakeSet(1);
}
public void Find_ShouldReturnRoot_When_SelfNotRoot(int[] start, int findIndex, int expected)
{
DisjointSet disjointSet = new DisjointSet(start);
int actual = disjointSet.Find(findIndex);
Assert.Equal(expected, actual);
}
static void Main(string[] args)
{
var ned = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
var quotientSet = new DisjointSet(ned[0]);
Func <int[]> readIndices = () =>
Console.ReadLine().Split(' ').Select(t => int.Parse(t) - 1).ToArray();
for (; ned[1] > 0; --ned[1])
{
var indices = readIndices();
quotientSet.Unite(indices[0], indices[1]);
}
var ans = 1;
for (; ned[2] > 0; --ned[2])
{
var indices = readIndices();
if (quotientSet.Find(indices[0]) == quotientSet.Find(indices[1]))
{
ans = 0;
}
}
Console.WriteLine("{0}", ans);
}
static void Main(string[] args)
{
var m = int.Parse(Console.ReadLine().Split(' ')[1]);
var records = Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
var maximum = records.Max();
var set = new DisjointSet(records.Length);
while (m > 0)
{
--m;
var to = 0;
var from = 0;
{
var toFrom = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
to = toFrom[0] - 1;
from = toFrom[1] - 1;
}
to = set.Find(to);
from = set.Find(from);
var recordsNumber = from == to ? records[from] : records[from] + records[to];
maximum = Math.Max(maximum, recordsNumber);
Console.WriteLine("{0}", maximum);
set.Unite(to, from);
records[set.Find(to)] = recordsNumber;
}
}
private static void TestMerge()
{
DisjointSet ds = new DisjointSet(10);
AssertTrue(ds.MergeSets(0, 1));
ds.CheckStructure();
AssertEquals(9, ds.NumberOfSets);
AssertTrue(ds.AreInSameSet(0, 1));
AssertTrue(ds.MergeSets(2, 3));
ds.CheckStructure();
AssertEquals(8, ds.NumberOfSets);
AssertTrue(ds.AreInSameSet(2, 3));
AssertFalse(ds.MergeSets(2, 3));
ds.CheckStructure();
AssertEquals(8, ds.NumberOfSets);
AssertFalse(ds.AreInSameSet(0, 2));
AssertTrue(ds.MergeSets(0, 3));
ds.CheckStructure();
AssertEquals(7, ds.NumberOfSets);
AssertTrue(ds.AreInSameSet(0, 2));
AssertTrue(ds.AreInSameSet(3, 0));
AssertTrue(ds.AreInSameSet(1, 3));
}
//private void Triangulate()
//{
// List<TriangulationPoint> points = new List<TriangulationPoint>();
// foreach (Vertex data in VertexList)
// points.Add(new TriangulationPoint(data.X, data.Y));
// PointSet set = new PointSet(points);
// IList<PolygonPoint> ppoint = new List<PolygonPoint>();
// foreach (Vertex data in VertexList)
// ppoint.Add(new PolygonPoint(data.X, data.Y));
// Polygon pol = new Polygon(ppoint);
// try
// {
// P2T.Triangulate(set);
// IList<DelaunayTriangle> triangles = set.Triangles;
// foreach (DelaunayTriangle angle in triangles)
// {
// FixedArray3<TriangulationPoint> point = angle.Points;
// EdgeList.Add(new Edge(new Vertex((int) point[0].X, (int) point[0].Y), new Vertex((int) point[1].X, (int) point[1].Y)));
// EdgeList.Add(new Edge(new Vertex((int) point[2].X, (int) point[2].Y), new Vertex((int) point[1].X, (int) point[1].Y)));
// EdgeList.Add(new Edge(new Vertex((int) point[0].X, (int) point[0].Y), new Vertex((int) point[2].X, (int) point[2].Y)));
// Debug.WriteLine(String.Format("X:{0}, Y:{0}", point[0].X, point[0].Y));
// //if (VertexList.Contains(aaa))
// // Debug.WriteLine("ada yang sama");
// }
// }
// catch (Exception ex)
// {
// Debug.WriteLine(ex.StackTrace);
// }
//}
//public int Distance(Vertex a, Vertex b)
//{
// return (int)(Math.Sqrt(Math.Pow(a.X - b.X, 2) + Math.Pow(a.Y - b.Y, 2)));
//}
#endregion
#region MST With Edge
public void GenerateKruskalMST()
{
ClearSolution();
if (VertexList.Count == 0)
{
return;
}
DisjointSet <Vertex> disjointSet = new DisjointSet <Vertex>(VertexList);
C5.IPriorityQueue <Edge> heap = new C5.IntervalHeap <Edge>(new EdgeComparer());
foreach (Edge e in EdgeList)
{
heap.Add(e);
}
while (heap.Count > 0 && disjointSet.Count > 0)
{
Edge s = heap.DeleteMin();
if (!disjointSet.IsSameSet(s.VertexFirst, s.VertexSecond))
{
disjointSet.Union(s.VertexFirst, s.VertexSecond);
EdgeSolution.Add(s);
}
}
}
public void Compute()
{
// clear previous results
SpanningTreeEdges.Clear();
// create disjoint set object
// fill in disjoint sets
DisjointSet dset = new DisjointSet(VisitedGraph.Vertices);
// create and fill in priority queue
PriorityQueue Q = new PriorityQueue(Weights, VisitedGraph.Edges);
// iterate over edges
while(Q.Count!=0)
{
IEdge e = Q.Peek();
Q.Pop();
IVertex u = dset.FindSet(e.Source);
IVertex v = dset.FindSet(e.Target);
if ( u != v )
{
SpanningTreeEdges.Add(e);
dset.Link(u, v);
}
}
}
public static void Main()
{
DisjointSet set = new DisjointSet();
// lets say we have 10 people, union represent who is friend with whom
for (int i = 1; i <= 10; i++)
{
set.MakeSet(i);
}
set.Union(1, 2);
set.Union(2, 4);
set.Union(3, 9);
set.Union(5, 6);
set.Union(7, 8);
set.Union(8, 9);
set.Union(2, 5);
int max = 0;
foreach (Node n in set.map.Values)
{
int curMax = set.FindSet(n).setTotal;
if (curMax > max)
{
max = curMax;
}
}
Console.WriteLine("Max friend group size is " + max);
}
public void Init(int numRow, int numCol)
{
/* size of maze */
this.numRow = numRow;
this.numCol = numCol;
numCell = numRow * numCol;
ds = new DisjointSet(numCell);
cellArr = new int[numRow, numCol];
hEdgeArr = new int[numRow + 1, numCol];
vEdgeArr = new int[numRow, numCol + 1];
/* each cell is element of disjoint set */
int cell = 1;
for (int i = 0; i < numRow; i++)
{
for (int j = 0; j < numCol; j++)
{
cellArr[i, j] = cell++;
}
}
/* initialize hEdgeArr and vEdgeArr */
InitEdgeArr();
rd = new Random();
}
private static void testAgainstNaiveRandomly()
{
int trials = 1000;
int iterations = 3000;
int numElems = 300;
for (int i = 0; i < trials; i++)
{
NaiveDisjointSet nds = new NaiveDisjointSet(numElems);
DisjointSet ds = new DisjointSet(numElems);
for (int j = 0; j < iterations; j++)
{
int k = rand.Next(numElems);
int l = rand.Next(numElems);
assert(ds.GetSizeOfSet(k) == nds.GetSizeOfSet(k));
assert(ds.AreInSameSet(k, l) == nds.AreInSameSet(k, l));
if (rand.NextDouble() < 0.1)
{
assert(ds.MergeSets(k, l) == nds.MergeSets(k, l));
}
assert(nds.GetNumberOfSets() == ds.GetNumberOfSets());
if (rand.NextDouble() < 0.001)
{
ds.CheckStructure();
}
}
ds.CheckStructure();
}
}
private static void testBigMerge()
{
int maxRank = 20;
int trials = 10000;
int numElems = 1 << maxRank; // Grows exponentially
DisjointSet ds = new DisjointSet(numElems);
for (int level = 0; level < maxRank; level++)
{
int mergeStep = 1 << level;
int incrStep = mergeStep * 2;
for (int i = 0; i < numElems; i += incrStep)
{
assert(!ds.AreInSameSet(i, i + mergeStep));
assert(ds.MergeSets(i, i + mergeStep));
}
// Now we have a bunch of sets of size 2^(level+1)
// Do random tests
int mask = -incrStep; // 0b11...100...00
for (int i = 0; i < trials; i++)
{
int j = rand.Next(numElems);
int k = rand.Next(numElems);
bool expect = (j & mask) == (k & mask);
assert(ds.AreInSameSet(j, k) == expect);
}
}
}
List <Edge> KruskalMST(Graph g)
{
EdgeComparer ec = new EdgeComparer();
List <Edge> allEdges = g.allEdges;
allEdges.Sort(ec);
DisjointSet ds = new DisjointSet();
foreach (Vertex v in g.allVertex.Values)
{
ds.MakeSet(v.id);
}
List <Edge> mst = new List <Edge>();
foreach (Edge e in allEdges)
{
int p1 = ds.FindSet(e.v1.id);
int p2 = ds.FindSet(e.v2.id);
if (p1 == p2)
{
continue;
}
mst.Add(e);
ds.Union(p1, p2);
}
return(mst);
}
/// <summary>
/// Connects the map areas given on the given map using the algorithm described in the class description.
/// </summary>
/// <param name="map">The map to connect.</param>
/// <param name="mapAreas">The map areas to connect on the given map.</param>
/// <param name="distanceCalc">The distance calculation that defines distance/neighbors.</param>
/// <param name="areaConnector">
/// The area connection strategy to use. Not all methods function on maps with concave areas
/// -- see respective class documentation for details.
/// </param>
/// ///
/// <param name="tunnelCreator">
/// The tunnel creation strategy to use. If null is specified, DirectLineTunnelCreator with
/// the distance calculation specified is used.
/// </param>
static public void Connect(ISettableMapView <bool> map, IReadOnlyList <MapArea> mapAreas, Distance distanceCalc, IAreaConnectionPointSelector areaConnector = null, ITunnelCreator tunnelCreator = null)
{
if (areaConnector == null)
{
areaConnector = new RandomConnectionPointSelector();
}
if (tunnelCreator == null)
{
tunnelCreator = new DirectLineTunnelCreator(distanceCalc);
}
var ds = new DisjointSet(mapAreas.Count);
while (ds.Count > 1) // Haven't unioned all sets into one
{
for (int i = 0; i < mapAreas.Count; i++)
{
int iClosest = findNearestMapArea(mapAreas, distanceCalc, i, ds);
var connectionPoints = areaConnector.SelectConnectionPoints(mapAreas[i], mapAreas[iClosest]);
tunnelCreator.CreateTunnel(map, connectionPoints.Item1, connectionPoints.Item2);
ds.MakeUnion(i, iClosest);
}
}
}
public KruskalMst(EdgeWeightedGraph graph)
{
mst = new Queue <Edge>();
var prioryQueue = new MinPQ <Edge>();
foreach (var edge in graph.GetEdges())
{
prioryQueue.Insert(edge);
}
var ds = new DisjointSet(graph.Vertices);
while (!prioryQueue.IsEmpty() && mst.Count < graph.Vertices - 1)
{
var edge = prioryQueue.DelMin();
int vertex = edge.Either();
int otherVertex = edge.Other(vertex);
if (ds.Connected(vertex, otherVertex))
{
continue;
}
ds.Union(vertex, otherVertex);
mst.Enqueue(edge);
}
}
public void Solve()
{
var n = sc.Integer();
var k = sc.Integer();
var l = sc.Integer();
var a = new DisjointSet(n);
var b = new DisjointSet(n);
for (int i = 0; i < k; i++)
{
a.Unite(sc.Integer() - 1, sc.Integer() - 1);
}
for (int i = 0; i < l; i++)
{
b.Unite(sc.Integer() - 1, sc.Integer() - 1);
}
var map = new HashMap <long, int>();
for (int i = 0; i < n; i++)
{
map[a[i] * 500000L + b[i]]++;
}
var ans = new int[n];
for (int i = 0; i < n; i++)
{
ans[i] = map[a[i] * 500000L + b[i]];
}
IO.Printer.Out.WriteLine(ans.AsJoinedString());
}
static void Main()
{
var points = ReadPoints();
var k = int.Parse(Console.ReadLine());
var sets = new DisjointSet <Point>(points);
var edges = CalculateEdges(points);
for (var i = points.Length; i < edges.Length; i++)
{
var edge = edges[i];
if (sets.Count == k)
{
if (sets.GetParent(edge.A).Equals(sets.GetParent(edge.B)))
{
continue;
}
Console.WriteLine("{0:f9}", edge.Distance);
return;
}
sets.Merge(edge.A, edge.B);
}
Console.WriteLine("0.000000000");
}
static long MinSumOfWeightsInSubTree(int[] from, int[] to, int[] weight)
{
var edges = new List <Edge>();
for (var i = 0; i < from.Length; i++)
{
var edge = new Edge(from[i], to[i], weight[i]);
edges.Add(edge);
}
edges = edges.OrderBy(c => c.Weight).ToList();
var usedNodes = new DisjointSet();
long weightSum = 0;
foreach (var edge in edges)
{
usedNodes.MakeSet(edge.From);
usedNodes.MakeSet(edge.To);
if (usedNodes.FindSet(edge.From) != usedNodes.FindSet(edge.To))
{
weightSum += edge.Weight;
usedNodes.Union(edge.From, edge.To);
}
}
return(weightSum);
}
public void DisjointSetTest()
{
var values = new List <int>()
{
1, 2, 3, 4, 5, 6, 7, 8
};
var sets = new List <DisjointSet <int> >();
foreach (var item in values)
{
var set = new DisjointSet <int>(item);
sets.Add(set);
}
var unionSet = sets[0];
for (int i = 1; i < sets.Count; i++)
{
unionSet = unionSet.Union(sets[i]);
}
var unionValues = unionSet.GetNodes();
//如何自己实现区并集
//如何证明两个集合值都是相等的呢？
//这样感觉的实现是对的！
Assert.AreEqual(values.Count, unionValues.Count());
foreach (var item in unionValues)
{
Console.WriteLine(item);
Assert.IsTrue(values.Contains(item.Value));
}
}
public DisjointSetTests()
{
_ds = new DisjointSet(6);
_ds.Union(0, 3);
_ds.Union(1, 3);
_ds.Union(2, 4);
}
private static void testMerge()
{
DisjointSet ds = new DisjointSet(10);
assert(ds.MergeSets(0, 1));
ds.CheckStructure();
assert(ds.GetNumberOfSets() == 9);
assert(ds.AreInSameSet(0, 1));
assert(ds.MergeSets(2, 3));
ds.CheckStructure();
assert(ds.GetNumberOfSets() == 8);
assert(ds.AreInSameSet(2, 3));
assert(!ds.MergeSets(2, 3));
ds.CheckStructure();
assert(ds.GetNumberOfSets() == 8);
assert(!ds.AreInSameSet(0, 2));
assert(ds.MergeSets(0, 3));
ds.CheckStructure();
assert(ds.GetNumberOfSets() == 7);
assert(ds.AreInSameSet(0, 2));
assert(ds.AreInSameSet(3, 0));
assert(ds.AreInSameSet(1, 3));
}
public void Solve()
{
var n = sc.Integer();
var m = sc.Integer();
var s = sc.Integer() - 1;
var ans = new List <int>();
var G = Enumerate(n, x => new List <int>());
for (int i = 0; i < m; i++)
{
var f = sc.Integer() - 1;
var t = sc.Integer() - 1;
G[Math.Min(f, t)].Add(Math.Max(f, t));
}
var set = new DisjointSet(n);
for (int i = n - 1; i >= 0; i--)
{
foreach (var to in G[i])
{
set.Unite(i, to);
}
if (set.IsUnited(i, s))
{
ans.Add(i);
}
}
ans.Reverse();
foreach (var x in ans)
{
IO.Printer.Out.WriteLine(x + 1);
}
}
public void MinimalSpanningTree(string filename)
{
Stopwatch clock = Stopwatch.StartNew();
//Read the input file
string[] lines = File.ReadAllLines(filename);
//create a forest F (a set of trees),
//where each vertex in the graph is a separate tree
int N = lines[0].Split(',').Length;
DisjointSet vertices = new DisjointSet(N);
//create a set S containing all the edges in the graph
//The tuple contains weight,vertex, vertex
List<Tuple<int, int, int>> edges = new List<Tuple<int, int, int>>();
int initialWeight = 0;
for (int i = 0; i < N; i++)
{
string[] edge = lines[i].Split(',');
for (int j = 0; j < i; j++)
{
if (edge[j] != "-")
{
int weight = Convert.ToInt32(edge[j]);
edges.Add(new Tuple<int, int, int>(weight, i, j));
initialWeight += weight;
}
}
}
//Sort edges to have the minimum weight at top
edges.Sort();
int k = 0;
//while S is nonempty and F is not yet spanning
int minSpanningTreeWeight = 0;
while (!vertices.isSpanning())
{
//remove an edge with minimum weight from S
//Since we have a sorted list we just go through the list
//if that edge connects two different trees, then add it to the forest,
//combining two trees into a single tree
if (vertices.Find(edges[k].Item2) != vertices.Find(edges[k].Item3))
{
vertices.Union(edges[k].Item2, edges[k].Item3);
minSpanningTreeWeight += edges[k].Item1;
}
k++;
}
clock.Stop();
Console.WriteLine("The saving is {0} ", initialWeight - minSpanningTreeWeight);
Console.WriteLine("Solution took {0} ms", clock.Elapsed.TotalMilliseconds);
}
List<Node> stable; /* Максимально стабильные области экстремума */
#endregion Fields
#region Constructors
public ComponentTree(GrayscaleBitmap original)
{
pixels = original.DecreasingCountingSort();
accessible = new Int32[original.Width, original.Height];
for (Int32 i = 0; i < original.Width; i++)
{
for (Int32 j = 0; j < original.Height; j++)
{
accessible[i, j] = Int32.MinValue;
}
}
QNode = new DisjointSet(Length);
QTree = new DisjointSet(Length);
nodes = new Node[Length];
lowestNode = new Int32[Length];
stable = new List<Node>();
MSERDetector();
}
public void GenerateEuclideanKruskalMST()
{
if (VertexList.Count == 0)
return;
DateTime start = DateTime.Now;
DisjointSet<Vertex> disjointSet = new DisjointSet<Vertex>(VertexList);
EdgeSolution.Clear();
C5.IPriorityQueue<Edge> heap = new C5.IntervalHeap<Edge>(new EdgeComparer());
//Triangulate();
//DelaunayTriangulation2d triangulator = new DelaunayTriangulation2d();
//IList<Triangle> triangles = triangulator.Triangulate(new List<Vertex>(VertexList));
//foreach (Triangle triangle in triangles)
//{
// Edge e = new Edge(triangle.Vertex1, triangle.Vertex2);
// heap.Add(e);
// EdgeList.Add(e);
// e = new Edge(triangle.Vertex1, triangle.Vertex3);
// heap.Add(e);
// EdgeList.Add(e);
// e = new Edge(triangle.Vertex3, triangle.Vertex2);
// heap.Add(e);
// EdgeList.Add(e);
//}
//this.VisitedVertex = VertexList.Count;
for (int i = 0; i < VertexList.Count - 1; i++)
for (int j = i + 1; j < VertexList.Count; j++)
{
Edge e = new Edge(VertexList[i], VertexList[j]);
heap.Add(e);
}
while (heap.Count > 0 && disjointSet.Count > 0)
{
Edge s = heap.DeleteMin();
if (!disjointSet.IsSameSet(s.VertexFirst, s.VertexSecond))
{
disjointSet.Union(s.VertexFirst, s.VertexSecond);
EdgeSolution.Add(s);
}
}
Debug.WriteLine((DateTime.Now - start).TotalMilliseconds + " ms");
//this.VisitedVertex = VertexList.Count;
}
void Start()
{
gridSize = gridCbrtSize * gridCbrtSize * gridCbrtSize;
gridPosition = this.transform.position;
float gridPositionAdjustment = (float)gridCbrtSize * blockSpacing / 2f;
Debug.Log (gridPositionAdjustment);
gridPosition.x -= gridPositionAdjustment;
gridPosition.z -= gridPositionAdjustment;
openState = new int[gridSize];
visualizerBlock = new GameObject[gridSize];
disjointSet = new DisjointSet (gridSize);
StartCoroutine (BuildGrid ());
// join all 'top' indices to check percolation later
int topRowFirstIndex = (int)(gridSize / gridCbrtSize) * (gridCbrtSize-1);
for(int i = topRowFirstIndex; i < gridSize-1; i++)
{
disjointSet.Join (i, gridSize-1);
}
}
public void GenerateKruskalMST()
{
ClearSolution();
if (VertexList.Count == 0)
return;
DisjointSet<Vertex> disjointSet = new DisjointSet<Vertex>(VertexList);
C5.IPriorityQueue<Edge> heap = new C5.IntervalHeap<Edge>(new EdgeComparer());
foreach(Edge e in EdgeList)
heap.Add(e);
while (heap.Count > 0 && disjointSet.Count > 0)
{
Edge s = heap.DeleteMin();
if (!disjointSet.IsSameSet(s.VertexFirst, s.VertexSecond))
{
disjointSet.Union(s.VertexFirst, s.VertexSecond);
EdgeSolution.Add(s);
}
}
}
public void GenerateOurKruskalMST(int bucket, double max, double min)
{
if (VertexList.Count == 0)
return;
if (max == min)
{
GenerateKruskalMST();
return;
}
DisjointSet<Vertex> disjointSet = new DisjointSet<Vertex>(VertexList);
ClearSolution();
C5.IPriorityQueue<Edge>[] bucketHeap = new C5.IntervalHeap<Edge>[bucket];
for (int i = 0; i < bucketHeap.Length; i++)
{
bucketHeap[i] = new C5.IntervalHeap<Edge>(new EdgeComparer());
}
int factor = bucket - 1;
double diff = max - min;
foreach(Edge e in EdgeList)
{
bucketHeap[(int)Math.Floor((((e.Length - min) / (diff)) * (factor)))].Add(e);
}
for (int i = 0; i < bucket && disjointSet.Count > 0; i++)
{
while (bucketHeap[i].Count > 0 && disjointSet.Count > 0)
{
Edge s = bucketHeap[i].DeleteMin();
if (!disjointSet.IsSameSet(s.VertexFirst, s.VertexSecond))
{
disjointSet.Union(s.VertexFirst, s.VertexSecond);
EdgeSolution.Add(s);
}
}
}
}
private void solve()
{
DisjointSet ds = new DisjointSet(B - A + 1);
for (long d = P; d < B - A; d++)
{
if (isPrime((int)d))
{
for (long i = (d - A % d) % d; d + i <= B - A; i = i + d) ds.union(i, d + i);
}
}
setNumber = ds.numberOfSets();
}
public void GenerateEuclideanOurKruskalMST(int bucket)
{
if (VertexList.Count == 0)
return;
DateTime start = DateTime.Now;
DisjointSet<Vertex> disjointSet = new DisjointSet<Vertex>(VertexList);
EdgeSolution.Clear();
C5.IPriorityQueue<Edge>[] heap2 = new C5.IntervalHeap<Edge>[bucket];
C5.IPriorityQueue<Edge> heap = new C5.IntervalHeap<Edge>(new EdgeComparer());
for(int i=0;i<heap2.Length;i++)
{
heap2[i] = new C5.IntervalHeap<Edge>(new EdgeComparer());
}
//this.VisitedVertex = VertexList.Count;
for (int i = 0; i < VertexList.Count - 1; i++)
for (int j = i + 1; j < VertexList.Count; j++)
{
Edge e = new Edge(VertexList[i], VertexList[j]);
heap.Add(e);
}
double max = heap.FindMax().Length;
double min = heap.FindMin().Length;
while (heap.Count > 0)
{
Edge s = heap.DeleteMin();
heap2[(int) Math.Floor((((s.Length - min) / (max - min)) * (bucket-1)))].Add(s);
}
for (int i = 0; i < bucket && disjointSet.Count > 0; i++)
{
while (heap2[i].Count > 0 && disjointSet.Count > 0)
{
Edge s = heap2[i].DeleteMin();
if (!disjointSet.IsSameSet(s.VertexFirst, s.VertexSecond))
{
disjointSet.Union(s.VertexFirst, s.VertexSecond);
EdgeSolution.Add(s);
}
}
}
Debug.WriteLine((DateTime.Now - start).TotalMilliseconds + " ms");
//this.VisitedVertex = VertexList.Count;
}
