mirror of
https://github.com/TheAlgorithms/C-Plus-Plus.git
synced 2026-05-07 05:42:03 +08:00
clang-format and clang-tidy fixes for b8c37d09
This commit is contained in:
github-actions
@@ -1,25 +1,26 @@
|
||||
/**
|
||||
* @file
|
||||
* @brief [DSU (Disjoint sets)](https://en.wikipedia.org/wiki/Disjoint-set-data_structure)
|
||||
* @brief [DSU (Disjoint
|
||||
* sets)](https://en.wikipedia.org/wiki/Disjoint-set-data_structure)
|
||||
* @details
|
||||
* It is a very powerful data structure that keeps track of different
|
||||
* clusters(sets) of elements, these sets are disjoint(doesnot have a common element).
|
||||
* Disjoint sets uses cases : for finding connected components in a graph,
|
||||
* used in Kruskal's algorithm for finding Minimum Spanning tree.
|
||||
* clusters(sets) of elements, these sets are disjoint(doesnot have a common
|
||||
* element). Disjoint sets uses cases : for finding connected components in a
|
||||
* graph, used in Kruskal's algorithm for finding Minimum Spanning tree.
|
||||
* Operations that can be performed:
|
||||
* 1) UnionSet(i,j): add(element i and j to the set)
|
||||
* 2) findSet(i): returns the representative of the set to which i belogngs to.
|
||||
* 3) get_max(i),get_min(i) : returns the maximum and minimum
|
||||
* Below is the class-based approach which uses the heuristic of path compression.
|
||||
* Using path compression in findSet(i),we are able to get to the representative of i
|
||||
* in O(1) time.
|
||||
* 3) get_max(i),get_min(i) : returns the maximum and minimum
|
||||
* Below is the class-based approach which uses the heuristic of path
|
||||
* compression. Using path compression in findSet(i),we are able to get to the
|
||||
* representative of i in O(1) time.
|
||||
* @author [AayushVyasKIIT](https://github.com/AayushVyasKIIT)
|
||||
* @see dsu_union_rank.cpp
|
||||
*/
|
||||
|
||||
#include <cassert> /// for assert
|
||||
#include <iostream> /// for IO operations
|
||||
#include <vector> /// for std::vector
|
||||
#include <cassert> /// for assert
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
@@ -29,139 +30,136 @@ using std::vector;
|
||||
* @brief Disjoint sets union data structure, class based representation.
|
||||
* @param n number of elements
|
||||
*/
|
||||
class dsu{
|
||||
private:
|
||||
vector<uint64_t> p; ///<keeps track of the parent of ith element
|
||||
vector<uint64_t> depth; ///<tracks the depth(rank) of i in the tree
|
||||
vector<uint64_t> setSize;///<size of each chunk(set)
|
||||
vector<uint64_t> maxElement;/// <maximum of each set to which i belongs to
|
||||
vector<uint64_t> minElement;/// <minimum of each set to which i belongs to
|
||||
public:
|
||||
/**
|
||||
* @brief contructor for initialising all data members.
|
||||
* @param n number of elements
|
||||
*/
|
||||
explicit dsu(uint64_t n){
|
||||
p.assign(n,0);
|
||||
/// initially, all of them are their own parents
|
||||
for(uint64_t i=0;i<n;i++){
|
||||
p[i] = i;
|
||||
}
|
||||
/// initially all have depth are equals to zero
|
||||
depth.assign(n,0);
|
||||
maxElement.assign(n,0);
|
||||
minElement.assign(n,0);
|
||||
for(uint64_t i=0;i<n;i++){
|
||||
depth[i] = 0;
|
||||
maxElement[i] = i;
|
||||
minElement[i] = i;
|
||||
}
|
||||
setSize.assign(n,0);
|
||||
/// initially set size will be equals to one
|
||||
for(uint64_t i=0;i<n;i++){
|
||||
setSize[i]=1;
|
||||
}
|
||||
class dsu {
|
||||
private:
|
||||
vector<uint64_t> p; ///< keeps track of the parent of ith element
|
||||
vector<uint64_t> depth; ///< tracks the depth(rank) of i in the tree
|
||||
vector<uint64_t> setSize; ///< size of each chunk(set)
|
||||
vector<uint64_t> maxElement; /// <maximum of each set to which i belongs to
|
||||
vector<uint64_t> minElement; /// <minimum of each set to which i belongs to
|
||||
public:
|
||||
/**
|
||||
* @brief contructor for initialising all data members.
|
||||
* @param n number of elements
|
||||
*/
|
||||
explicit dsu(uint64_t n) {
|
||||
p.assign(n, 0);
|
||||
/// initially, all of them are their own parents
|
||||
for (uint64_t i = 0; i < n; i++) {
|
||||
p[i] = i;
|
||||
}
|
||||
/// initially all have depth are equals to zero
|
||||
depth.assign(n, 0);
|
||||
maxElement.assign(n, 0);
|
||||
minElement.assign(n, 0);
|
||||
for (uint64_t i = 0; i < n; i++) {
|
||||
depth[i] = 0;
|
||||
maxElement[i] = i;
|
||||
minElement[i] = i;
|
||||
}
|
||||
setSize.assign(n, 0);
|
||||
/// initially set size will be equals to one
|
||||
for (uint64_t i = 0; i < n; i++) {
|
||||
setSize[i] = 1;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Method to find the representative of the set to which i belongs
|
||||
* to, T(n) = O(1)
|
||||
* @param i element of some set
|
||||
* @returns representative of the set to which i belongs to.
|
||||
*/
|
||||
uint64_t findSet(uint64_t i) {
|
||||
/// using path compression
|
||||
if (p[i] == i) {
|
||||
return i;
|
||||
}
|
||||
return (p[i] = findSet(p[i]));
|
||||
}
|
||||
/**
|
||||
* @brief Method that combines two disjoint sets to which i and j belongs to
|
||||
* and make a single set having a common representative.
|
||||
* @param i element of some set
|
||||
* @param j element of some set
|
||||
* @returns void
|
||||
*/
|
||||
void UnionSet(uint64_t i, uint64_t j) {
|
||||
/// check if both belongs to the same set or not
|
||||
if (isSame(i, j)) {
|
||||
return;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Method to find the representative of the set to which i belongs to, T(n) = O(1)
|
||||
* @param i element of some set
|
||||
* @returns representative of the set to which i belongs to.
|
||||
*/
|
||||
uint64_t findSet(uint64_t i){
|
||||
/// using path compression
|
||||
if(p[i]==i){
|
||||
return i;
|
||||
}
|
||||
return (p[i] = findSet(p[i]));
|
||||
}
|
||||
/**
|
||||
* @brief Method that combines two disjoint sets to which i and j belongs to
|
||||
* and make a single set having a common representative.
|
||||
* @param i element of some set
|
||||
* @param j element of some set
|
||||
* @returns void
|
||||
*/
|
||||
void UnionSet(uint64_t i,uint64_t j){
|
||||
/// check if both belongs to the same set or not
|
||||
if(isSame(i,j)){
|
||||
return;
|
||||
}
|
||||
// we find the representative of the i and j
|
||||
uint64_t x = findSet(i);
|
||||
uint64_t y = findSet(j);
|
||||
|
||||
//we find the representative of the i and j
|
||||
uint64_t x = findSet(i);
|
||||
uint64_t y = findSet(j);
|
||||
// always keeping the min as x
|
||||
// shallow tree
|
||||
if (depth[x] > depth[y]) {
|
||||
std::swap(x, y);
|
||||
}
|
||||
// making the shallower root's parent the deeper root
|
||||
p[x] = y;
|
||||
|
||||
//always keeping the min as x
|
||||
//shallow tree
|
||||
if(depth[x]>depth[y]){
|
||||
std::swap(x,y);
|
||||
}
|
||||
//making the shallower root's parent the deeper root
|
||||
p[x] = y;
|
||||
|
||||
//if same depth then increase one's depth
|
||||
if(depth[x] == depth[y]){
|
||||
depth[y]++;
|
||||
}
|
||||
//total size of the resultant set.
|
||||
setSize[y] += setSize[x];
|
||||
//changing the maximum elements
|
||||
maxElement[y] = std::max(maxElement[x],maxElement[y]);
|
||||
minElement[y] = std::min(minElement[x],minElement[y]);
|
||||
// if same depth then increase one's depth
|
||||
if (depth[x] == depth[y]) {
|
||||
depth[y]++;
|
||||
}
|
||||
/**
|
||||
* @brief A utility function which check whether i and j belongs to
|
||||
* same set or not
|
||||
* @param i element of some set
|
||||
* @param j element of some set
|
||||
* @returns `true` if element `i` and `j` ARE in the same set
|
||||
* @returns `false` if element `i` and `j` are NOT in same set
|
||||
*/
|
||||
bool isSame(uint64_t i,uint64_t j){
|
||||
if(findSet(i) == findSet(j)){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
// total size of the resultant set.
|
||||
setSize[y] += setSize[x];
|
||||
// changing the maximum elements
|
||||
maxElement[y] = std::max(maxElement[x], maxElement[y]);
|
||||
minElement[y] = std::min(minElement[x], minElement[y]);
|
||||
}
|
||||
/**
|
||||
* @brief A utility function which check whether i and j belongs to
|
||||
* same set or not
|
||||
* @param i element of some set
|
||||
* @param j element of some set
|
||||
* @returns `true` if element `i` and `j` ARE in the same set
|
||||
* @returns `false` if element `i` and `j` are NOT in same set
|
||||
*/
|
||||
bool isSame(uint64_t i, uint64_t j) {
|
||||
if (findSet(i) == findSet(j)) {
|
||||
return true;
|
||||
}
|
||||
/**
|
||||
* @brief prints the minimum, maximum and size of the set to which i belongs to
|
||||
* @param i element of some set
|
||||
* @returns void
|
||||
*/
|
||||
vector<uint64_t> get(uint64_t i){
|
||||
vector<uint64_t> ans;
|
||||
ans.push_back(get_min(i));
|
||||
ans.push_back(get_max(i));
|
||||
ans.push_back(size(i));
|
||||
return ans;
|
||||
|
||||
}
|
||||
/**
|
||||
* @brief A utility function that returns the size of the set to which i belongs to
|
||||
* @param i element of some set
|
||||
* @returns size of the set to which i belongs to
|
||||
*/
|
||||
uint64_t size(uint64_t i){
|
||||
return setSize[findSet(i)];
|
||||
}
|
||||
/**
|
||||
* @brief A utility function that returns the max element of the set to which i belongs to
|
||||
* @param i element of some set
|
||||
* @returns maximum of the set to which i belongs to
|
||||
*/
|
||||
uint64_t get_max(uint64_t i){
|
||||
return maxElement[findSet(i)];
|
||||
}
|
||||
/**
|
||||
* @brief A utility function that returns the min element of the set to which i belongs to
|
||||
* @param i element of some set
|
||||
* @returns minimum of the set to which i belongs to
|
||||
*/
|
||||
uint64_t get_min(uint64_t i){
|
||||
return minElement[findSet(i)];
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
/**
|
||||
* @brief prints the minimum, maximum and size of the set to which i belongs
|
||||
* to
|
||||
* @param i element of some set
|
||||
* @returns void
|
||||
*/
|
||||
vector<uint64_t> get(uint64_t i) {
|
||||
vector<uint64_t> ans;
|
||||
ans.push_back(get_min(i));
|
||||
ans.push_back(get_max(i));
|
||||
ans.push_back(size(i));
|
||||
return ans;
|
||||
}
|
||||
/**
|
||||
* @brief A utility function that returns the size of the set to which i
|
||||
* belongs to
|
||||
* @param i element of some set
|
||||
* @returns size of the set to which i belongs to
|
||||
*/
|
||||
uint64_t size(uint64_t i) { return setSize[findSet(i)]; }
|
||||
/**
|
||||
* @brief A utility function that returns the max element of the set to
|
||||
* which i belongs to
|
||||
* @param i element of some set
|
||||
* @returns maximum of the set to which i belongs to
|
||||
*/
|
||||
uint64_t get_max(uint64_t i) { return maxElement[findSet(i)]; }
|
||||
/**
|
||||
* @brief A utility function that returns the min element of the set to
|
||||
* which i belongs to
|
||||
* @param i element of some set
|
||||
* @returns minimum of the set to which i belongs to
|
||||
*/
|
||||
uint64_t get_min(uint64_t i) { return minElement[findSet(i)]; }
|
||||
};
|
||||
/**
|
||||
* @brief Self-implementation Test case #1
|
||||
@@ -169,16 +167,16 @@ class dsu{
|
||||
*/
|
||||
static void test1() {
|
||||
/* the minimum, maximum and size of the set*/
|
||||
uint64_t n = 10;///< number of items
|
||||
dsu d(n+1);///< object of class disjoint sets
|
||||
//set 1
|
||||
d.UnionSet(1,2); //performs union operation on 1 and 2
|
||||
d.UnionSet(1,4); //performs union operation on 1 and 4
|
||||
vector<uint64_t> ans = {1,4,3};
|
||||
for(uint64_t i=0;i<ans.size();i++){
|
||||
assert(d.get(4).at(i) == ans[i]); //makes sure algorithm works fine
|
||||
uint64_t n = 10; ///< number of items
|
||||
dsu d(n + 1); ///< object of class disjoint sets
|
||||
// set 1
|
||||
d.UnionSet(1, 2); // performs union operation on 1 and 2
|
||||
d.UnionSet(1, 4); // performs union operation on 1 and 4
|
||||
vector<uint64_t> ans = {1, 4, 3};
|
||||
for (uint64_t i = 0; i < ans.size(); i++) {
|
||||
assert(d.get(4).at(i) == ans[i]); // makes sure algorithm works fine
|
||||
}
|
||||
cout << "Test case# 1: passed"<<endl;
|
||||
cout << "Test case# 1: passed" << endl;
|
||||
}
|
||||
/**
|
||||
* @brief Self-implementation Test case #2
|
||||
@@ -186,30 +184,29 @@ static void test1() {
|
||||
*/
|
||||
static void test2() {
|
||||
/* the minimum, maximum and size of the set */
|
||||
uint64_t n = 10;///< number of items
|
||||
dsu d(n+1);///< object of class disjoint sets
|
||||
//set 1
|
||||
d.UnionSet(3,5);
|
||||
d.UnionSet(5,6);
|
||||
d.UnionSet(5,7);
|
||||
vector<uint64_t> ans = {3,7,4};
|
||||
for(uint64_t i=0;i<ans.size();i++){
|
||||
assert(d.get(3).at(i) == ans[i]); //makes sure algorithm works fine
|
||||
uint64_t n = 10; ///< number of items
|
||||
dsu d(n + 1); ///< object of class disjoint sets
|
||||
// set 1
|
||||
d.UnionSet(3, 5);
|
||||
d.UnionSet(5, 6);
|
||||
d.UnionSet(5, 7);
|
||||
vector<uint64_t> ans = {3, 7, 4};
|
||||
for (uint64_t i = 0; i < ans.size(); i++) {
|
||||
assert(d.get(3).at(i) == ans[i]); // makes sure algorithm works fine
|
||||
}
|
||||
cout << "Test case# 2: passed"<<endl;
|
||||
cout << "Test case# 2: passed" << endl;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Main function
|
||||
* @returns 0 on exit
|
||||
* */
|
||||
int main(){
|
||||
uint64_t n = 10;///< number of items
|
||||
dsu d(n+1);///< object of class disjoint sets
|
||||
int main() {
|
||||
uint64_t n = 10; ///< number of items
|
||||
dsu d(n + 1); ///< object of class disjoint sets
|
||||
|
||||
test1(); //< test case# 1
|
||||
test2(); //< test case# 2
|
||||
|
||||
test1(); //< test case# 1
|
||||
test2(); //< test case# 2
|
||||
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user