public void UnionSets2() { var disjointSets = new DisjointSets(5); Assert.AreEqual(5, disjointSets.ElementCount); Assert.AreEqual(5, disjointSets.DisjointSetCount); disjointSets.UnionSets(0, 4); Assert.AreEqual(5, disjointSets.ElementCount); Assert.AreEqual(4, disjointSets.DisjointSetCount); disjointSets.UnionSets(4, 0); Assert.AreEqual(4, disjointSets.DisjointSetCount); disjointSets.UnionSets(3, 0); Assert.AreEqual(3, disjointSets.DisjointSetCount); disjointSets.UnionSets(1, 2); Assert.AreEqual(2, disjointSets.DisjointSetCount); disjointSets.UnionSets(2, 4); Assert.AreEqual(1, disjointSets.DisjointSetCount); disjointSets.UnionSets(1, 3); Assert.AreEqual(1, disjointSets.DisjointSetCount); disjointSets.UnionSets(4, 4); Assert.AreEqual(1, disjointSets.DisjointSetCount); disjointSets.UnionSets(2, 0); Assert.AreEqual(1, disjointSets.DisjointSetCount); }
public KruskalMST(Graph g) { BinaryHeapPQ <Edge> pq = new BinaryHeapPQ <Edge>(); for (int v = 0; v < g.V; v++) { for (int i = 0; i < g.Deg(v); i++) { pq.Insert(new Edge() { U = v, V = g.AdjV(v, i), W = g.AdjW(v, i) }); } } DisjointSets ds = new DisjointSets(g.V); while (pq.Count > 0 && mst.Count < g.V - 1) { Edge e = pq.ExtractMin(); int v = e.U; int w = e.V; if (ds.FindSet(v) != ds.FindSet(w)) { ds.Union(v, w); mst.Add(e); } } }
// Use disjoint sets to create the clusters private static SortedDictionary <double, int>[] DerivePointClustersFromRootSets(SortedDictionary <double, Double2>[] curveRootSets) { // First, gather all points and create the disjoint sets data structure var allPoints = curveRootSets.SelectMany(set => set.Values).ToArray(); var disjointSets = new DisjointSets(allPoints.Length); // Now, reunite the clusters for (int i = 0; i < allPoints.Length; i++) { for (int j = i + 1; j < allPoints.Length; j++) { if (DoubleUtils.RoughlyEquals(allPoints[i], allPoints[j])) { disjointSets.UnionSets(i, j); } } } // Finally, attribute the clusters to the original curves int length = curveRootSets.Length; var clusters = new SortedDictionary <double, int> [length]; int k = 0; for (int i = 0; i < length; i++) { clusters[i] = new SortedDictionary <double, int>(); foreach (var kvp in curveRootSets[i]) { clusters[i][kvp.Key] = disjointSets.FindParentOfSets(k++); } } return(clusters); }
//performs initialization before the main generation algorithm. private void initializeGeneration(int the_progress_max) { //mark that the panel can be drawn now if (!my_maze_generated) { my_maze_generated = true; lblStart.Visible = true; lblFinish.Visible = true; } //clear out old labels lblSolutionPathLength.Text = ""; lblTimeToSolveMaze.Text = ""; //clear out old structures my_maze_graph = null; my_user_solution_path = null; my_buffer = null; //clear out old values my_accepting_user_input = false; //setup progressbar pbrProgress.Value = 0; pbrProgress.Maximum = the_progress_max; my_walls = new LinkedList <Wall>(); my_removed_walls = new LinkedList <Wall>(); //prepare sets my_d_sets = new DisjointSets <DSInteger>(); }
public void testWorkedExample() { // Should be the following when finished: // {a, b, c, d}, {e, f, g}, {h, i}, and {j} // 1. initial sets DisjointSets <string> disjSets = new DisjointSets <string>("a", "b", "c", "d", "e", "f", "g", "h", "i", "j"); Assert.AreEqual(10, disjSets.numberDisjointSets()); Assert.AreEqual(1, disjSets.find("a").Size()); Assert.AreEqual(1, disjSets.find("b").Size()); Assert.AreEqual(1, disjSets.find("c").Size()); Assert.AreEqual(1, disjSets.find("d").Size()); Assert.AreEqual(1, disjSets.find("e").Size()); Assert.AreEqual(1, disjSets.find("f").Size()); Assert.AreEqual(1, disjSets.find("g").Size()); Assert.AreEqual(1, disjSets.find("h").Size()); Assert.AreEqual(1, disjSets.find("i").Size()); Assert.AreEqual(1, disjSets.find("j").Size()); // 2. (b, d) disjSets.union("b", "d"); Assert.AreEqual(9, disjSets.numberDisjointSets()); assertArrayEquals(disjSets.find("b"), disjSets.find("d")); // 3. (e, g) disjSets.union("e", "g"); Assert.AreEqual(8, disjSets.numberDisjointSets()); assertArrayEquals(disjSets.find("e"), disjSets.find("g")); // 4. (a, c) disjSets.union("a", "c"); Assert.AreEqual(7, disjSets.numberDisjointSets()); assertArrayEquals(disjSets.find("a"), disjSets.find("c")); // 5. (h, i) disjSets.union("h", "i"); Assert.AreEqual(6, disjSets.numberDisjointSets()); assertArrayEquals(disjSets.find("h"), disjSets.find("i")); // 6. (a, b) disjSets.union("a", "b"); Assert.AreEqual(5, disjSets.numberDisjointSets()); assertArrayEquals(disjSets.find("a"), disjSets.find("b")); assertArrayEquals(disjSets.find("b"), disjSets.find("c")); assertArrayEquals(disjSets.find("c"), disjSets.find("d")); // 7. (e, f) disjSets.union("e", "f"); Assert.AreEqual(4, disjSets.numberDisjointSets()); assertArrayEquals(disjSets.find("e"), disjSets.find("f")); assertArrayEquals(disjSets.find("f"), disjSets.find("g")); // 8. (b, c) disjSets.union("b", "c"); Assert.AreEqual(4, disjSets.numberDisjointSets()); assertArrayEquals(disjSets.find("a"), disjSets.find("b")); assertArrayEquals(disjSets.find("b"), disjSets.find("c")); assertArrayEquals(disjSets.find("c"), disjSets.find("d")); }
public void DisjoinSetsPerformanceTest() { #region Arrange var numElements = 1000000; var djs = new DisjointSets(numElements); #endregion #region Act var firstRoot = 0; var secondRoot = numElements / 2; djs.CreateSet(firstRoot); djs.CreateSet(secondRoot); for (int i = 0; i < numElements; i++) { if (i != firstRoot && i != secondRoot) { if (i < secondRoot) { djs.AddToSet(firstRoot, i); } else { djs.AddToSet(secondRoot, i); } } } djs.Union(firstRoot, secondRoot); #endregion #region Assert Assert.AreEqual(1, djs.SetsCount); for (int i = 0; i < numElements; i++) { Assert.AreEqual(0, djs.GetIncludingSetId(i)); } #endregion }
static void Kruskal(Graph graph) { int weight = 0; List <Edge> sortedEdges = graph.edges.OrderBy(o => o.Weight).ToList(); DisjointSets ds = new DisjointSets(graph.vertices); foreach (Edge edge in sortedEdges) { string u = edge.Source; string v = edge.Destination; string set_u = ds.findParent(u); string set_v = ds.findParent(v); if (set_u != set_v) { weight += edge.Weight; ds.mergeByRank(set_u, set_v); } } Console.WriteLine("Weight of minimum spanning tree is " + weight); }
/// <summary>Kruskal algorithm.</summary> /// <param name="graph">Undirected weighted graph</param> /// <returns>Minimal spanning tree</returns> public static IUndirectedGraph <TVertexId, TVertexProperty, TEdgeProperty> Kruskal <TVertexId, TVertexProperty, TEdgeProperty>( this IUndirectedGraph <TVertexId, TVertexProperty, TEdgeProperty> graph) where TEdgeProperty : IWeighted { var mst = new UndirectedSimpleGraph <TVertexId, TVertexProperty, TEdgeProperty>( graph.Vertices.Select(v => v.Id).ToArray()); var vertexSets = new DisjointSets <Vertex <TVertexId> >(graph.Vertices); var edgeHeap = new Heap <Edge <TVertexId> >( (edge1, edge2) => graph.Properties[edge1].Weight.CompareTo(graph.Properties[edge2].Weight) ); foreach (Edge <TVertexId> edge in graph.Edges) { edgeHeap.Push(edge); } while (vertexSets.Count > 1 && edgeHeap.Count > 0) { Edge <TVertexId> edge = edgeHeap.Pop(); if (!vertexSets.IsSameSet(edge.Source, edge.Destination)) { mst.AddEdge(edge, graph.Properties[edge]); } vertexSets.UnionSet(edge.Source, edge.Destination); } return(mst); }
static void Main(string[] args) { DisjointSets ds = new DisjointSets(); 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).Data); Console.WriteLine(ds.FindSet(2).Data); Console.WriteLine(ds.FindSet(3).Data); Console.WriteLine(ds.FindSet(4).Data); Console.WriteLine(ds.FindSet(5).Data); Console.WriteLine(ds.FindSet(6).Data); Console.WriteLine(ds.FindSet(7).Data); }
public List <Edge> GetMST(Graph graph) { List <Edge> mst = new List <Edge>(); // Sort the edges in ascending order of their weights List <Edge> sortedEdges = graph.AllEdges.OrderBy(e => e.Weight).ToList(); int totalNumOfVertices = graph.AllVertices.Count(); DisjointSets <int> ds = new DisjointSets <int>(); foreach (Edge e in sortedEdges) { if (mst.Count() >= totalNumOfVertices) { // total number of edges in an mst will be total number of vertices in a graph -1 break; } if (!ds.Find(e.StId, e.EndId)) { // the stId and endId vertex of the edge are not in the same set // hence adding this edge wont create a cycle ds.Union(e.StId, e.EndId); mst.Add(e); } } return(mst); }
/// <summary> /// Compute comparability for a method's parameters based on the types of the parameters. Two parameters /// are considered comparable if one can be assigned to the other. /// </summary> /// <param name="parameters">the parameters</param> /// <seealso cref="TypeHelper.TypesAreAssignmentCompatible"/> /// <returns>comparability sets for the parameters</returns> public static HashSet <HashSet <string> > ParameterTypeComparability(IEnumerable <IParameterDefinition> parameters) { Contract.Requires(parameters != null); Contract.Ensures(Contract.Result <HashSet <HashSet <string> > >() != null); Dictionary <IParameterDefinition, int> ids = new Dictionary <IParameterDefinition, int>(); DisjointSets cmp = new DisjointSets(); foreach (var p in parameters) { ids.Add(p, cmp.AddElement()); } foreach (var lhs in parameters) { Contract.Assume(ids.ContainsKey(lhs), "Error tracking parameter " + lhs.Name); foreach (var rhs in parameters) { Contract.Assume(ids.ContainsKey(rhs), "Error tracking parameter " + rhs.Name); if (TypeHelper.TypesAreAssignmentCompatible(lhs.Type.ResolvedType, rhs.Type.ResolvedType, true)) { cmp.Union(cmp.FindSet(ids[lhs]), cmp.FindSet(ids[rhs])); } } } var result = new HashSet <HashSet <string> >(ids.Keys.GroupBy(p => cmp.FindSet(ids[p])).Select(g => new HashSet <string>(g.Select(p => p.Name.Value)))); return(result); }
public void testUnionIllegalArgumentException1() { DisjointSets <string> disjSets = new DisjointSets <string>( "a"); disjSets.union("b", "a"); }
public void MakeSet_ThrowsOnAlreadyExistingElement() { var sets = new DisjointSets <int>(); sets.MakeSet(1); Assert.That(() => sets.MakeSet(1), Throws.ArgumentException); }
public static List <Edge> MinimumSpanningTree(IGraph g) { var result = new List <Edge>(); var edges = g.Edges().OrderBy(e => e.weight).ToArray(); var vertexCount = g.VertexesCount(); var sets = new DisjointSets <int>(); foreach (var edge in edges) { if (sets.ItemCount == vertexCount) { break; } var setFrom = sets.MakeSet(edge.from); var setTo = sets.MakeSet(edge.to); if (setFrom != setTo) { sets.Union(setFrom, setTo); result.Add(edge); } } return(result); }
public static bool DetectCycleinUndirectedGraphUsingDisjointSets <T>(this Graph <T> g, out long v1, out long v2) { DisjointSets ds = new DisjointSets(); v1 = Int32.MaxValue; v2 = Int32.MaxValue; //Step 1: Make a set for all nodes in graph foreach (var v in g.AllVertex.Values) { ds.MakeSet(v.Id); } //For all edges, findset each vertex. // If the findset does not match, do union else you have found a cycle foreach (var edge in g.AllEdges) { var n1 = ds.FindSet(edge.V1.Id); var n2 = ds.FindSet(edge.V2.Id); if (n1 == n2) { v1 = edge.V1.Id; v2 = edge.V2.Id; return(true); } ds.Union(edge.V1.Id, edge.V2.Id); } return(false); }
public void MakeSet_ThrowsOnAlreadyExistingElement2() { var sets = new DisjointSets <int>(new int[] { 1, 2, 3 }); Assert.That(() => sets.MakeSet(1), Throws.ArgumentException); Assert.That(() => sets.MakeSet(2), Throws.ArgumentException); Assert.That(() => sets.MakeSet(3), Throws.ArgumentException); }
public void Union_ThrowsOnElementsInTheSameSet2() { var sets = new DisjointSets <int>(new int[] { 1, 2, 3, 4 }); sets.Union(4, 3); sets.Union(3, 2); sets.Union(2, 1); Assert.That(() => sets.Union(1, 4), Throws.ArgumentException); }
// Complete the maxRegion function below. static int maxRegion(int[][] matrix) { var xOffset = new[] { -1, 0, 1, -1 }; var yOffset = new[] { -1, -1, -1, 0 }; var ds = new DisjointSets(); var rows = matrix.Length; var cols = matrix[0].Length; var max = 0; Func <int, int, bool> isValid = (int x, int y) => { return(x >= 0 && x < cols && y >= 0 && y < rows); }; for (int y = 0; y < rows; y++) { for (int x = 0; x < cols; x++) { if (matrix[y][x] == 0) { continue; } var current = new CellKey(x, y); ds.AddNew(current); max = Math.Max(max, 1); for (int index = 0; index < xOffset.Length; index++) { var ox = x + xOffset[index]; var oy = y + yOffset[index]; if (!isValid(ox, oy)) { continue; } if (matrix[oy][ox] == 0) { continue; } var offset = new CellKey(ox, oy); if (ds.Find(current) != ds.Find(offset)) { max = Math.Max(max, ds.Union(current, offset)); } } } } return(max); }
public void GetSet_TypicalCase() { var elements = new int[] { 1, 2, 3, 4, 5 }; var sets = new DisjointSets <int>(elements); foreach (int element in elements) { Assert.That(sets.GetSet(element), Is.EquivalentTo(new SortedSet <int>(new int[] { element }))); } }
public void Constructor_TypicalCase() { var elements = new int[] { 1, 2, 3, 4, 5 }; var sets = new DisjointSets <int>(elements); foreach (var element in elements) { Assert.That(sets.FindSet(element), Is.EqualTo(element)); } }
/// <summary> /// /// </summary> /// <param name="declaringTypeName"></param> /// <param name="name"></param> /// <param name="parameterTypes"></param> /// <param name="ids"></param> /// <param name="comparability"></param> /// <param name="arrayIndexes"></param> public MethodSummary(string declaringTypeName, string name, string[] parameterTypes, Dictionary <string, int> ids, DisjointSets comparability, Dictionary <string, HashSet <string> > arrayIndexes) { this.Name = name; this.ParameterTypes = parameterTypes; this.ids = ids; this.comparability = comparability; this.arrayIndexes = arrayIndexes; this.DeclaringTypeName = declaringTypeName; }
public void FindSet_WithPreExistingElements() { var elements = new int[] { 1, 2, 3, 4 }; var sets = new DisjointSets <int>(elements); foreach (var element in elements) { Assert.That(sets.FindSet(element), Is.EqualTo(element)); } }
public void RunTest() { DisjointSets ds = new DisjointSets(_numElements); int[] e2set = new int[_numElements]; HashSet <int>[] sets = new HashSet <int> [_numSets]; for (int i = 0; i < _numSets; i++) { sets[i] = new HashSet <int>(); } Random rnd = new Random(); for (int i = 0; i < _numElements; i++) { int nset = rnd.Next(_numSets); e2set[i] = nset; sets[nset].Add(i); } foreach (HashSet <int> set in sets) { Queue <int> q = new Queue <int>(set); if (q.Count == 0) { continue; } int last = q.Dequeue(); while (q.Count > 0) { int cur = q.Dequeue(); ds.Union(ds.FindSet(last), ds.FindSet(cur)); last = cur; } } int[] reps = new int[_numSets]; for (int i = 0; i < _numSets; i++) { reps[i] = -1; } for (int i = 0; i < _numElements; i++) { int rep = ds.FindSet(i); int nset = e2set[i]; if (reps[nset] == -1) { reps[nset] = rep; } else if (reps[nset] != rep) { throw new TestFailedException("Test with " + _numElements + " elements and " + _numSets + " sets: wrong representant"); } } }
public void UnionSets1() { var disjointSets = new DisjointSets(1); Assert.AreEqual(1, disjointSets.ElementCount); Assert.AreEqual(1, disjointSets.DisjointSetCount); disjointSets.UnionSets(0, 0); Assert.AreEqual(1, disjointSets.ElementCount); Assert.AreEqual(1, disjointSets.DisjointSetCount); }
private int[] _repShuffle; // Used to pick the "right" representant for // Havlak's loop analysis /// <summary> /// Constructs an instance of the union-find data structure. /// </summary> /// <param name="a">set adapter</param> /// <param name="elems">The list set elements. It is assumed that the list index of each set element /// matched the index returned by the set adapter.</param> public UnionFind(ISetAdapter <T> a, IList <T> elems) { _index = a.Index; _elems = new List <T>(elems); _repShuffle = new int[elems.Count]; for (int i = 0; i < _elems.Count; i++) { Debug.Assert(_index[_elems[i]] == i); _repShuffle[i] = i; } _impl = new DisjointSets(elems.Count); }
public void Union() { var sets = new DisjointSets <int>(new int[] { 1, 2, 3, 4, 5, 6 }); sets.Union(1, 2); Assert.That(sets.FindSet(1), Is.EqualTo(1).Or.EqualTo(2)); Assert.That(sets.FindSet(2), Is.EqualTo(1).Or.EqualTo(2)); foreach (int i in new int[] { 3, 4, 5, 6 }) { Assert.That(sets.FindSet(i), Is.EqualTo(i)); } }
public void testConstructors() { DisjointSets <string> disjSets = new DisjointSets <string>(); Assert.AreEqual(0, disjSets.numberDisjointSets()); disjSets = new DisjointSets <string>("a", "a", "b"); Assert.AreEqual(2, disjSets.numberDisjointSets()); disjSets = new DisjointSets <string>(CollectionFactory.CreateQueue <string>(new[] { "a", "a", "b" })); Assert.AreEqual(2, disjSets.numberDisjointSets()); }
/// <summary> /// Set the number of rows and columns for the maze to be generated, be sure to call <see cref="GenerateMaze()"/> /// after invoking this constructor. /// </summary> /// <param name="rows">The number of rows for the maze.</param> /// <param name="cols">The number of columns for the maze.</param> public MazeGenerator(int rows, int cols) { Rows = rows; Cols = cols; CellNum = Rows * Cols; grid = new Cell[CellNum]; sets = new DisjointSets(CellNum); for (int i = 0; i < grid.Length; ++i) { grid[i] = new Cell(true, true, true, true); } }
public void testMakeSet() { DisjointSets <string> disjSets = new DisjointSets <string>(); disjSets.makeSet("a"); Assert.AreEqual(1, disjSets.numberDisjointSets()); disjSets.makeSet("a"); Assert.AreEqual(1, disjSets.numberDisjointSets()); disjSets.makeSet("b"); Assert.AreEqual(2, disjSets.numberDisjointSets()); }
public void Test01NonGeneric() { for (var i = 1; i <= ElementsNumber; i += 1 + i / (10 + _random.Next(0, 10))) { Console.WriteLine($"i = {i}"); var djs = new DisjointSets(ElementsNumber); foreach (var el in RandomShuffle(_seq)) { djs.Union(el, el % i); } VerifySets(djs, i); } }
public void RunTest() { DisjointSets ds = new DisjointSets(_numElements); int[] e2set = new int[_numElements]; HashSet<int>[] sets = new HashSet<int>[_numSets]; for (int i = 0; i < _numSets; i++) { sets[i] = new HashSet<int>(); } Random rnd = new Random(); for (int i = 0; i < _numElements; i++) { int nset = rnd.Next(_numSets); e2set[i] = nset; sets[nset].Add(i); } foreach (HashSet<int> set in sets) { Queue<int> q = new Queue<int>(set); if (q.Count == 0) continue; int last = q.Dequeue(); while (q.Count > 0) { int cur = q.Dequeue(); ds.Union(ds.FindSet(last), ds.FindSet(cur)); last = cur; } } int[] reps = new int[_numSets]; for (int i = 0; i < _numSets; i++) reps[i] = -1; for (int i = 0; i < _numElements; i++) { int rep = ds.FindSet(i); int nset = e2set[i]; if (reps[nset] == -1) reps[nset] = rep; else if (reps[nset] != rep) throw new TestFailedException("Test with " + _numElements + " elements and " + _numSets + " sets: wrong representant"); } }