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");
}
}
