public void QU_Basic() { string path = Path.Combine(_baseAddress, "BasicAPI_Test_input.txt"); var connect = new int[5, 2] { { 0, 1 }, { 1, 3 }, { 5, 4 }, { 5, 4 }, //to test repeated union call { 3, 5 } }; int N = 6; var QU = new QuickUnion(N); for (int i = 0; i <= connect.GetUpperBound(0); i++) { int p = connect[i, 0]; int q = connect[i, 1]; QU.Union(p, q); } //0 and 4 are expected to be connected to the same components Assert.AreEqual(QU.Find(0), QU.Find(4)); Assert.AreEqual(QU.ComponentsCount, 2); }
static void Main(string[] args) { var quickFinder = new QuickUnion(10); quickFinder.Union(1, 3); /*0 3 2 3 4 5 6 7 8 9 */ quickFinder.Union(3, 8); /*0 3 2 8 4 5 6 7 8 9 */ quickFinder.Union(7, 4); /*0 3 2 8 4 5 6 4 8 9 */ quickFinder.Union(5, 8); /*0 3 2 8 4 8 6 4 8 9 */ quickFinder.Union(0, 5); /*8 3 2 8 4 8 6 4 8 9 */ Console.WriteLine(quickFinder.Find(1, 5)); quickFinder.Print(); // ----------------------------- var quickFinderWeighted = new QuickUnionWeighted(10); quickFinderWeighted.Union(1, 3); quickFinderWeighted.Union(3, 8); quickFinderWeighted.Union(7, 4); quickFinderWeighted.Union(5, 8); quickFinderWeighted.Union(0, 5); /*3 3 2 3 4 3 6 4 3 9 */ Console.WriteLine(quickFinderWeighted.Find(1, 5)); quickFinderWeighted.Print(); }
public Kruskal(WeightedGraph G) { var V = G.V(); var uf = new QuickUnion(V); var pq = new MinPQ <Edge>(); mst = new List <Edge>(); foreach (Edge e in G.edges()) { pq.Enqueue(e); } while (!pq.IsEmpty && mst.Count < V - 1) { var e = pq.DelMin(); var v = e.either(); var w = e.other(v); if (!uf.IsConnected(v, w)) { uf.Union(v, w); mst.Add(e); } } }
public void IsConnected_NodesAreNotConnected_ReturnsFalse() { QuickUnion quickUnion = new QuickUnion(5); quickUnion.Union(1, 2); Assert.IsFalse(quickUnion.IsConnected(2, 3)); }
public void IsConnected_NodesAreConnected_ReturnsTrue() { QuickUnion quickUnion = new QuickUnion(5); quickUnion.Union(1, 2); Assert.IsTrue(quickUnion.IsConnected(1, 2)); }
public void Connected_InitCollection_NumbersNotConnected() { // Arrange var qf = new QuickUnion(10); // Assert Assert.False(qf.Connected(1, 2)); }
public void IsConnected_MultipleUnions_ReturnsTrue() { QuickUnion quickUnion = new QuickUnion(5); quickUnion.Union(1, 2); quickUnion.Union(2, 3); Assert.IsTrue(quickUnion.IsConnected(1, 3)); }
public void IsConnected_UnionOfConnectedNodes_ReturnsTrue() { QuickUnion quickUnion = new QuickUnion(5); quickUnion.Union(1, 2); quickUnion.Union(4, 5); quickUnion.Union(1, 4); Assert.IsTrue(quickUnion.IsConnected(2, 4)); }
public void InitWorks() { IUnionFind uf = new QuickUnion(10); int[] ids = uf.GetIds(); for (int i = 0; i < 10; i++) { Assert.AreEqual(i, ids[i]); } }
public void DemoTest() { IUnionFind uf = new QuickUnion(10); uf.Union(4, 3); int[] root = uf.GetIds(); Assert.AreEqual(3, root[3]); Assert.AreEqual(3, root[4]); uf.Union(3, 8); root = uf.GetIds(); Assert.AreEqual(8, root[3]); uf.Union(6, 5); root = uf.GetIds(); Assert.AreEqual(5, root[6]); uf.Union(9, 4); root = uf.GetIds(); Assert.AreEqual(8, root[9]); uf.Union(2, 1); root = uf.GetIds(); Assert.AreEqual(1, root[2]); Assert.IsTrue(uf.Connected(8, 9)); Assert.IsFalse(uf.Connected(5, 4)); uf.Union(5, 0); root = uf.GetIds(); Assert.AreEqual(0, root[5]); uf.Union(7, 2); root = uf.GetIds(); Assert.AreEqual(1, root[7]); uf.Union(6, 1); root = uf.GetIds(); Assert.AreEqual(1, root[0]); uf.Union(7, 3); root = uf.GetIds(); Assert.AreEqual(8, root[1]); Assert.AreEqual(1, root[0]); Assert.AreEqual(8, root[1]); Assert.AreEqual(1, root[2]); Assert.AreEqual(8, root[3]); Assert.AreEqual(3, root[4]); Assert.AreEqual(0, root[5]); Assert.AreEqual(5, root[6]); Assert.AreEqual(1, root[7]); Assert.AreEqual(8, root[8]); Assert.AreEqual(8, root[9]); }
public void Union_ConnectTwoElements_Should_BeConnected() { // Arrange var qf = new QuickUnion(10); // Act qf.Union(1, 2); // Assert Assert.True(qf.Connected(1, 2)); }
public void QuickUnionTest() { var pqPairs = CreatePairs(); var qu = new QuickUnion(10); qu.DoSearch(pqPairs); //all items are now connected - all indexes are 1 //Assert.IsFalse(arr.Any(i => i != 1)); }
static void Main(string[] args) { var quickUnion = new QuickUnion(10); quickUnion.Union(4, 3); quickUnion.Union(3, 8); quickUnion.Union(6, 5); quickUnion.Union(9, 4); quickUnion.Union(2, 1); Console.WriteLine(quickUnion); }
public void Union_ConnectedSequence_Should_BeConnected() { // Arrange var qf = new QuickUnion(10); // Act qf.Union(1, 2); qf.Union(3, 2); qf.Union(4, 3); // Assert Assert.True(qf.Connected(1, 4)); }
public void QuickFind_TinyFile_True() { var dots = new Dots(@"DataStore\tinyUF.txt"); var quickUnion = new QuickUnion(dots.Count); foreach (Tuple <int, int> item in dots.Items) { if (quickUnion.Connected(item.Item1, item.Item2)) { continue; } quickUnion.Union(item.Item1, item.Item2); } Assert.Equal(2, quickUnion.Count); }
public void TestingUFQuickUnion() { var unionFind = new QuickUnion(10); unionFind.Union(4, 3); unionFind.Union(3, 8); unionFind.Union(6, 5); unionFind.Union(9, 4); unionFind.Union(2, 1); unionFind.Union(8, 9); unionFind.Union(5, 0); unionFind.Union(7, 2); unionFind.Union(6, 1); unionFind.Union(1, 0); unionFind.Union(6, 7); }
public void QuickUnionFindTest() { QuickUnion uf = new QuickUnion(13); uf.Union(0, 1); uf.Union(1, 2); uf.Union(4, 5); uf.Union(0, 3); uf.Union(7, 8); uf.Union(8, 9); uf.Union(6, 11); uf.Union(11, 10); uf.Union(9, 12); uf.Union(1, 12); Assert.Equal(12, uf.Find(0)); Assert.Equal(5, uf.Find(4)); }
public void test_union_find() { var uf = new QuickUnion(10); uf.Union(1, 3); uf.Union(2, 3); uf.Union(5, 6); uf.Union(4, 5); Assert.True(uf.IsConnected(1, 3)); Assert.True(uf.IsConnected(2, 3)); Assert.True(uf.IsConnected(1, 2)); Assert.True(uf.IsConnected(4, 5)); Assert.True(uf.IsConnected(4, 6)); Assert.False(uf.IsConnected(1, 6)); Assert.False(uf.IsConnected(3, 4)); this.logger.WriteLine("Connected: {1, 2, 3}"); }
static void Main(string[] args) { Console.WriteLine("==== Quick Union ===="); IUnionFind qf = new QuickUnion(10); qf.union(9, 8); qf.union(4, 3); qf.union(3, 8); qf.union(7, 1); qf.union(2, 1); qf.union(6, 5); qf.union(5, 0); qf.union(0, 1); qf.union(5, 9); qf.print(); Console.WriteLine("Is 7 and 5 connected: " + qf.connected(7, 5)); Console.WriteLine("Is 9 and 3 connected: " + qf.connected(7, 5)); Console.WriteLine("Is 9 and 3 connected: " + qf.connected(1, 1)); Console.WriteLine("==== Weighted Union ===="); IUnionFind wf = new WeightedUnion(10); wf.union(1, 2); wf.union(4, 3); wf.union(2, 5); wf.union(5, 4); wf.union(9, 7); wf.union(6, 8); wf.union(0, 6); wf.union(0, 7); wf.union(5, 8); wf.print(); Console.WriteLine("Is 7 and 5 connected: " + wf.connected(7, 5)); Console.WriteLine("Is 9 and 3 connected: " + wf.connected(7, 5)); Console.WriteLine("Is 9 and 3 connected: " + wf.connected(1, 1)); }
public void QuickUnionTest() { QuickUnion uf = new QuickUnion(13); uf.Union(0, 1); uf.Union(1, 2); uf.Union(4, 5); uf.Union(0, 3); uf.Union(7, 8); uf.Union(8, 9); uf.Union(6, 11); uf.Union(11, 10); uf.Union(9, 12); uf.Union(1, 12); Assert.False(uf.IsConnected(2, 5)); Assert.True(uf.IsConnected(7, 12)); Assert.False(uf.IsConnected(6, 8)); Assert.True(uf.IsConnected(0, 12)); }
public int SolveMSt() { int mstCost = 0; _MstEdges = new List <Edge>(); QuickUnion Qu = new QuickUnion(_nodes + 1); Array.Sort(_EdgeCost, _EdgeList); for (int i = 0; i < _EdgeCost.Length; i++) { if (!Qu.Find(_EdgeList[i].a, _EdgeList[i].b)) { mstCost += _EdgeCost[i]; _MstEdges.Add(_EdgeList[i]); Qu.Union(_EdgeList[i].a, _EdgeList[i].b); } } return(mstCost); }
public void TestQuickUnion() { var input = new List <int[]>() { new int[] { 1, 3 }, new int[] { 1, 4 }, new int[] { 8, 9 } }; var N = 10; var uf = new QuickUnion(N); foreach (var item in input) { uf.Union(item[0], item[1]); } Assert.Equal(uf.Connected(3, 4), true); Assert.Equal(uf.Connected(9, 0), false); }
public static int GetMaximumGroup(IList <int[]> pairs, int n) { if (n <= 0 || pairs == null || pairs.Count == 0) { return(-1); } var unionFind = new QuickUnion(n); foreach (var item in pairs) { unionFind.Union(item[0], item[1]); } var groupCount = new Dictionary <int, int>(); // quick find and also path compression for (int i = 0; i < n; i++) { unionFind.QuickFindAndPathCompression(i); } // Find maximum group number for (int i = 0; i < n; i++) { var rootId = unionFind.QuickFind(i); if (!groupCount.ContainsKey(rootId)) { groupCount.Add(rootId, 1); } else { groupCount[rootId]++; } } return(groupCount.Values.Max()); }
public void QuickUnion_TwoSites() { var quickFind = new QuickUnion(10); TwoSitesCheck(quickFind); }
public void QuickUnion_AllConnected() { var quickFind = new QuickUnion(10); AllConnectedCheck(quickFind); }
public void QuickUnion_TransitiveCheck() { var quickFind = new QuickUnion(10); TransitiveCheck(quickFind); }
public void QuickUnion_SymmetricCheck() { var quickFind = new QuickUnion(10); SymmetricCheck(quickFind); }
public void QuickUnion_ReflexiveCheck() { var quickFind = new QuickUnion(10); ReflexiveCheck(quickFind); }
/// <summary> /// Leetcode 721 /// https://leetcode.com/problems/accounts-merge/ /// </summary> /// <param name="accounts"></param> /// <returns></returns> public static IList <IList <string> > AccountsMerge(IList <IList <string> > accounts) { var emailSet = getAllEmails(accounts); // https://leetcode.com/problems/accounts-merge/discuss/164699/C-Solution-(Union-Find)-beats-91.49 var emailList = emailSet.ToList(); var ordCmp = StringComparer.Ordinal; emailList.Sort(ordCmp); var emailNameMap = getEmailNameMap(accounts); var emailIdmap = new Dictionary <string, int>(); int index = 0; var emailLookup = new List <string>(); foreach (var item in emailList) { emailIdmap.Add(item, index); index++; emailLookup.Add(item); } var unionFind = new QuickUnion(emailSet.Count); unionFind.EmailIdMap = emailIdmap; foreach (var list in accounts) { for (int i = 1; i < list.Count - 1; i++) { var email1 = list[i]; var email2 = list[i + 1]; var connected = unionFind.Connected(email1, email2); if (!connected) { unionFind.Union(email1, email2); } } } // flat the tree for (int i = 0; i < emailSet.Count; i++) { unionFind.QuickFindAndPathCompression(i); } var dict = new Dictionary <int, List <string> >(); var parent = unionFind.GetParent(); for (int i = 0; i < parent.Length; i++) { var key = parent[i]; if (!dict.ContainsKey(key)) { dict.Add(key, new List <string>()); } dict[key].Add(emailLookup[i]); } // output a list var result = new List <IList <string> >(); foreach (var item in dict.Keys) { var list = new List <string>(); var email = emailLookup[item]; var name = emailNameMap[email]; list.Add(name); var values = dict[item]; list.AddRange(values); result.Add(list); } return(result); }
/// <summary> /// assume that maximum number of cities is 50 /// Map new road as integer quickly. /// using SortedDictionary /// https://github.com/jianminchen/Leetcode_Julia/blob/master/source%20code/23%20Merge%20K%20sorted%20lists%20-%20using%20minimum%20heap.cs /// </summary> /// <param name="noCities"></param> /// <param name="existingRoads"></param> /// <param name="newRoads"></param> /// <param name="roadWithCost"></param> /// <returns></returns> public static int getMinimumCost( int noCities, List <int[]> existingRoads, int newRoads, List <int[]> roadWithCost) { var quickUnion = new QuickUnion(noCities); foreach (var item in existingRoads) { // adjust the value of id from 0 to N - 1 quickUnion.Union(item[0] - 1, item[1] - 1); } int count = quickUnion.GetCount(); var newRoadMap = new SortedDictionary <int, Queue <int[]> >(); foreach (int[] item in roadWithCost) { var id1 = item[0] - 1; var id2 = item[1] - 1; var roadCost = item[2]; if (!newRoadMap.ContainsKey(roadCost)) { newRoadMap.Add(roadCost, new Queue <int[]>()); } newRoadMap[roadCost].Enqueue(new int[] { id1, id2 }); } var totalCost = 0; while (newRoadMap.Count > 0) { int minCost = newRoadMap.First().Key; var ids = newRoadMap[minCost].Dequeue(); if (newRoadMap[minCost].Count == 0) { newRoadMap.Remove(minCost); } var id1 = ids[0]; var id2 = ids[1]; var connected = quickUnion.Connected(id1, id2); if (connected) { continue; } totalCost += minCost; quickUnion.Union(id1, id2); // Union, not Connected if (quickUnion.GetCount() == 1) { break; } } if (quickUnion.GetCount() > 1) { return(-1); } return(totalCost); }