LC & CF Update

Author: Tanjim131

Code Templates/Data Structure/DSU.cpp

@@ -1,70 +1,56 @@
-#include <iostream>
-#include <cstdio>
-#include <cmath>
-#include <vector>
-#include <queue>
-#include <stack>
-#include <cstring>
-#include <algorithm>
-#include <map>
-#include <unordered_map>
-#include <set>
-#include <unordered_set>
-#include <sstream>
-
-using namespace std;
-
-#define LL long long
-#define pb push_back
-#define mp make_pair
-#define PII pair < int , int >
-#define infile(f) freopen(f,"r",stdin)
-#define outfile(f) freopen(f,"w",stdout)
-
-inline bool checkBit(int mask,int pos) { return (bool) (mask & (1 << pos)); }
-inline int setBit(int mask,int pos) { return (mask | (1 << pos)); }
-//int dx[]={1,0,-1,0};
-//int dy[]={0,1,0,-1}; //4 Direction
-//int dx[]={1,1,0,-1,-1,-1,0,1};
-//int dy[]={0,1,1,1,0,-1,-1,-1};//8 direction
-
-const int MAXN = 30000 + 5; // adjust max size accordingly
-int par[MAXN],Rank[MAXN];
-
-void initialize(int n){
- for(int i = 0 ; i < n ; i++){
- par[i] = i; // initially everybody is their own parent
- Rank[i] = 1; // subset size 1
- }
-}
-
-int Find(int i){
- while(par[i] != i){
- par[i] = par[par[i]]; // setting's i's grandparent as i's new parent, flattening the tree, path compression
- i = par[i]; // walking up the ladder;
- }
- return i;
-}
-
-void Union(int a,int b){
- int rootA = Find(a);
- int rootB = Find(b);
-
- if(rootA == rootB) return; // if they are connected already, no need to go further
-
- if(Rank[rootA] < Rank[rootB]){ // balancing the tree
- par[rootA] = rootB;
- Rank[rootB] += Rank[rootA];
- } else{
- par[rootB] = rootA;
- Rank[rootA] += Rank[rootB];
- }
-}
-
-int main(){
-
-
- return 0;
-}
-
-
+class DSU{
+ vector <int> parent, rank, minimum, maximum, total_elements;
+ 
+ public:
+ DSU(int n){
+ parent.resize(n + 1);
+ minimum.resize(n + 1);
+ maximum.resize(n + 1);
+ total_elements.assign(n + 1, 1);
+ rank.assign(n + 1, 0);
+ initialize(n);
+ }
+
+ void initialize(int n){
+ for(int i = 1 ; i <= n ; ++i){
+ parent[i] = i;
+ minimum[i] = i;
+ maximum[i] = i;
+ }
+ }
+
+ int find_parent(int element){
+ if(parent[element] == element) return element;
+ return parent[element] = find_parent(parent[element]);
+ }
+ 
+ void union_by_rank(int a, int b){
+ int pa = find_parent(a);
+ int pb = find_parent(b);
+ if(pa == pb) return;
+ if(rank[pa] == rank[pb]) ++rank[pa];
+ if(rank[pa] > rank[pb]){
+ parent[pb] = pa;
+ total_elements[pa] += total_elements[pb];
+ minimum[pa] = min(minimum[pa], minimum[pb]);
+ maximum[pa] = max(maximum[pa], maximum[pb]);
+ } else{
+ parent[pa] = pb;
+ total_elements[pb] += total_elements[pa];
+ minimum[pb] = min(minimum[pa], minimum[pb]);
+ maximum[pb] = max(maximum[pa], maximum[pb]);
+ }
+ }
+
+ int getSize(int v){
+ return total_elements[find_parent(v)];
+ }
+
+ int getMin(int v){
+ return minimum[find_parent(v)];
+ }
+
+ int getMax(int v){
+ return maximum[find_parent(v)];
+ }
+};

Codeforces/667-3-C.cpp Codeforces/1200/667-3-C.cppCodeforces/667-3-C.cpp renamed to Codeforces/1200/667-3-C.cpp

@@ -0,0 +1,56 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+class DSU{
+ vector <int> parent, rank;
+ 
+ public:
+ DSU(int n){
+ parent.resize(n + 1);
+ rank.assign(n + 1, 0);
+ initialize_parent(n);
+ }
+
+ void initialize_parent(int n){
+ for(int i = 1 ; i <= n ; ++i){
+ parent[i] = i;
+ }
+ }
+
+ int find_parent(int element){
+ if(parent[element] == element) return element;
+ return parent[element] = find_parent(parent[element]);
+ }
+ 
+ void union_by_rank(int a, int b){
+ int pa = find_parent(a);
+ int pb = find_parent(b);
+ if(pa == pb) return;
+ if(rank[pa] == rank[pb]) ++rank[pa];
+ if(rank[pa] > rank[pb]){
+ parent[pb] = pa;
+ } else{
+ parent[pa] = pb;
+ }
+ }
+};
+
+int main(int argc, char const *argv[])
+{
+ int n, m;
+ cin >> n >> m;
+ DSU dsu(n);
+ for(int i = 0 ; i < m ; ++i){
+ string q;
+ int u,v;
+ cin >> q >> u >> v;
+ if(q == "union"){
+ dsu.union_by_rank(u, v);
+ } else{
+ cout << (dsu.find_parent(u) == dsu.find_parent(v) ? "YES" : "NO") << '\n';
+ }
+ }
+ return 0;
+}

Codeforces/EDU/DSU/Step 1/1-A.cpp

@@ -0,0 +1,85 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+class DSU{
+ vector <int> parent, rank, minimum, maximum, total_elements;
+ 
+ public:
+ DSU(int n){
+ parent.resize(n + 1);
+ minimum.resize(n + 1);
+ maximum.resize(n + 1);
+ total_elements.assign(n + 1, 1);
+ rank.assign(n + 1, 0);
+ initialize(n);
+ }
+
+ void initialize(int n){
+ for(int i = 1 ; i <= n ; ++i){
+ parent[i] = i;
+ minimum[i] = i;
+ maximum[i] = i;
+ }
+ }
+
+ int find_parent(int element){
+ if(parent[element] == element) return element;
+ return parent[element] = find_parent(parent[element]);
+ }
+ 
+ void union_by_rank(int a, int b){
+ int pa = find_parent(a);
+ int pb = find_parent(b);
+ if(pa == pb) return;
+ if(rank[pa] == rank[pb]) ++rank[pa];
+ if(rank[pa] > rank[pb]){
+ parent[pb] = pa;
+ total_elements[pa] += total_elements[pb];
+ minimum[pa] = min(minimum[pa], minimum[pb]);
+ maximum[pa] = max(maximum[pa], maximum[pb]);
+ } else{
+ parent[pa] = pb;
+ total_elements[pb] += total_elements[pa];
+ minimum[pb] = min(minimum[pa], minimum[pb]);
+ maximum[pb] = max(maximum[pa], maximum[pb]);
+ }
+ }
+
+ int getSize(int v){
+ return total_elements[find_parent(v)];
+ }
+
+ int getMin(int v){
+ return minimum[find_parent(v)];
+ }
+
+ int getMax(int v){
+ return maximum[find_parent(v)];
+ }
+};
+
+int main(int argc, char const *argv[])
+{
+ ios_base::sync_with_stdio(false);
+ cin.tie(0);
+ int n, m;
+ cin >> n >> m;
+ DSU dsu(n);
+ for(int i = 0 ; i < m ; ++i){
+ string q;
+ cin >> q;
+ if(q == "union"){
+ int u,v;
+ cin >> u >> v;
+ dsu.union_by_rank(u, v);
+ } else{
+ int v;
+ cin >> v;
+ cout << dsu.getMin(v) << " " << dsu.getMax(v) << " " << dsu.getSize(v) << '\n';
+ }
+ }
+ return 0;
+}

Codeforces/EDU/DSU/Step 1/1-B.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+ uint32_t reverseBits(uint32_t n) {
+ uint32_t reversed = 0;
+ for(int i = 0 ; i < 32 ; ++i){
+ reversed = (reversed << 1) | ((n & (1 << i)) >> i);
+ }
+ return reversed;
+ }
+};
+
+/*
+uint32_t reverseBits(uint32_t n) {
+ uint32_t reversed = 0;
+ for(int i = 0 ; i < 32 ; ++i){
+ reversed = (reversed << 1) | (n & 1);
+ n >>= 1;
+ }
+ return reversed;
+}
+*/

LeetCode/Easy/190 - Reverse Bits.cpp

@@ -0,0 +1,42 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ * int val;
+ * TreeNode *left;
+ * TreeNode *right;
+ * TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+
+struct Info{
+ long long sum;
+ int count;
+};
+
+class Solution {
+public:
+ int getLevels(TreeNode *root){
+ if(root == NULL) return 0;
+ return 1 + max(getLevels(root -> left), getLevels(root -> right));
+ }
+ void getInfo(TreeNode *root, int tL, vector<Info> &info, int cL = 0){
+ if(root == NULL) return;
+ if(cL == tL) return;
+ info[cL].sum += root -> val;
+ ++info[cL].count;
+ getInfo(root -> left, tL, info, cL + 1);
+ getInfo(root -> right, tL, info, cL + 1);
+ }
+ vector<double> averageOfLevels(TreeNode* root) {
+ int levels = getLevels(root);
+ vector <Info> info(levels); // info[0] --> sum, info[1] --> count
+ getInfo(root, levels, info);
+ vector <double> average(levels);
+ for(int i = 0 ; i < levels ; ++i){
+ average[i] = info[i].sum * 1.0 / info[i].count;
+ }
+ return average;
+ }
+};