disjoint-set | Disjoint-set data structure for JavaScript | Dataset library

DataStructures library must be loaded as stated by user DNF

You can load it by

using DataStructures

Before that though you must install it

The algorithm wokrs as follows: you start from a node x, make x point to its granparent, then move on to the granparent itself, you continue until you find the root because the parent of the root is the root itself.

Look at the picture, you are actually halving the set by transforming it into a binary tree (it's not a proper binary tree but it can represented as such).

Let's say we have a set like this:

8->7->6->5->4->3->2->1->0

where the arrow means the parent (e.g. 8->7 = the parent of 8 is 7)

Say we call Find(8)

first iteration:

Your it->insert(1) attempts to change a set inside the outer set>, and in so doing might change the position in which *it should be stored in the outer set, which would breach the class invariants by not keeping the elements sorted. To avoid that, the outer set only gives it const access to the set elements

If you want to modify a set element, you need to extract it from the outer set, modify it, then insert it back wherever it should now go.

It seems that you are looking for connected components.
Consider the following graph.

You can have a look at the portion library I developed (https://github.com/AlexandreDecan/portion). It's available on PyPI as well (pip install portion).

using namespace std; sets you up for trouble, as it creates the opportunity for names to be the same as yours. Namespaces are in place to protect name collisions. In your case, std::rank is a name. Delete using namespace std; and you should fix the problem. See Why is "using namespace std;" considered bad practice?.

Another bad practice in your code: Why should I not #include ?.

From the Wikipedia article about dynamic connectivity:

The set V of vertices of the graph is fixed, but the set E of edges can change. The three cases, in order of difficulty, are:

• Edges are only added to the graph (this can be called incremental connectivity);
• Edges are only deleted from the graph (this can be called decremental connectivity);
• Edges can be either added or deleted (this can be called fully dynamic connectivity).

A union-find data structure (also known as a disjoint set data structure) can be used in the first case. You can use the union operation to join two components when adding an edge, and the find operation to test whether two vertices are in the same component. However, a union-find data structure has no operation to support deleting an edge, splitting a component into two newly-disconnected components; so it cannot be used to solve the other two cases of the dynamic connectivity problem.

It turns out that it is possible to build all of Boost while using ICU for those components that support the ICU feature, as follows.

./vcpkg install boost-locale[icu] boost-regex[icu] boost --triplet x64-windows --recurse

Source: How do I build boost with ICU support without having to build most components of boost twice?

One easy way to accomplish this is to store additional information in Disjoint Set Union (DSU) data structure.

If we store not only parent information but the size of each disjoint set, then we can easily check if we are only left with one disjoint set, by comparing size of first disjoint set with the total amount of elements.

There's an easy way to implement this without using extra space:

In the tutorial you linked P[u] stores parent of element u, and in case u is the root of disjoint set it stores itself so u is root if P[u] === u

In our modified implementation we mark root nodes with negative numbers so u is a root of disjoint set if P[u] < 0, and now we can also store size of disjoint set as a negative number so if P[u] >= 0 it acts as in standard DSU implementation to show the parent of some node, and if it's negative it shows that current node is the root and -P[u] denotes the size of disjoint set this root represents.

Sample code (JavaScript, using only Path compression optimization so complexity for all functions is O(log N)):