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