Showing posts with label Disjoint Set Union. Show all posts
Showing posts with label Disjoint Set Union. Show all posts

Monday, April 6, 2020

[GYM] M - Mountaineers

Author            : Dipu Kumar Mohanto 
                    CSE, Batch - 6
                    BRUR.
Problem Statement : M - Mountaineers
Source            : Codeforces GYM
Category          : Data Structure
Algorithm         : Disjoint Set Union
Verdict           : Accepted
Tutorial : https://codeforces.com/blog/entry/75369

  1. #include "bits/stdc++.h"  
  2.   
  3. using namespace std;  
  4.   
  5. #define ll            long long int  
  6. #define endl          '\n'  
  7.   
  8. signed main()  
  9. {  
  10.       ios_base::sync_with_stdio(false);  
  11.       cin.tie(nullptr);  
  12.   
  13.       #ifndef ONLINE_JUDGE  
  14.             freopen("in.txt""r", stdin);  
  15.       #endif // ONLINE_JUDGE  
  16.   
  17.       int n, m, q;  
  18.       cin >> n >> m >> q;  
  19.       vector < vector <int> > cell_node(n + 1, vector <int>(m + 1));  
  20.       vector < vector <int> > grid(n + 1, vector <int>(m + 1));  
  21.       int ptr = 0;  
  22.       for (int i = 1; i <= n; i++)  
  23.       {  
  24.             for (int j = 1; j <= m; j++)  
  25.             {  
  26.                   cin >> grid[i][j];  
  27.                   cell_node[i][j] = ++ptr;  
  28.             }  
  29.       }  
  30.       struct Edge  
  31.       {  
  32.             int u, v, w;  
  33.             Edge(int u = 0, int v = 0, int w = 0)  
  34.                   : u(u), v(v), w(w) {}  
  35.             bool operator < (const Edge &other) const  
  36.             {  
  37.                   return w < other.w;  
  38.             }  
  39.       };  
  40.       int dr[4] = {+0, -1, +0, +1};  
  41.       int dc[4] = {-1, +0, +1, +0};  
  42.       function <bool(intint)> valid = [&](int r, int c)  
  43.       {  
  44.             return r >= 1 and r <= n and c >= 1 and c <= m;  
  45.       };  
  46.       vector <Edge> edges;  
  47.       for (int i = 1; i <= n; i++)  
  48.       {  
  49.             for (int j = 1; j <= m; j++)  
  50.             {  
  51.                   for (int f = 0; f < 4; f++)  
  52.                   {  
  53.                         int x = i + dr[f];  
  54.                         int y = j + dc[f];  
  55.                         if (valid(x, y))  
  56.                         {  
  57.                               int u = cell_node[i][j];  
  58.                               int v = cell_node[x][y];  
  59.                               int w = max(grid[i][j], grid[x][y]);  
  60.                               edges.emplace_back(u, v, w);  
  61.                         }  
  62.                   }  
  63.             }  
  64.       }  
  65.       sort(edges.begin(), edges.end());  
  66.       vector <int> par(ptr + 1);  
  67.       vector <int> max_cost(ptr + 1);  
  68.       vector <int> ans(q + 1);  
  69.       set <int> st[ptr + 1];  
  70.       for (int i = 1; i <= q; i++)  
  71.       {  
  72.             int x1, y1, x2, y2;  
  73.             cin >> x1 >> y1 >> x2 >> y2;  
  74.             if (x1 == x2 and y1 == y2)  
  75.             {  
  76.                   ans[i] = grid[x1][y1];  
  77.                   continue;  
  78.             }  
  79.             int u = cell_node[x1][y1];  
  80.             int v = cell_node[x2][y2];   
  81.             st[u].insert(i);  
  82.             st[v].insert(i);  
  83.       }  
  84.       for (int i = 1; i <= ptr; i++) par[i] = i;  
  85.       function <int(int)> find_rep = [&](int r)  
  86.       {  
  87.             if (r == par[r]) return r;  
  88.             return par[r] = find_rep(par[r]);  
  89.       };  
  90.       for (Edge it : edges)  
  91.       {  
  92.             int u = it.u;  
  93.             int v = it.v;  
  94.             int w = it.w;  
  95.             int p = find_rep(u);  
  96.             int q = find_rep(v);  
  97.             if (p == q) continue;  
  98.             int szp = st[p].size();  
  99.             int szq = st[q].size();  
  100.             if (szp < szq)  
  101.             {  
  102.                   swap(p, q);  
  103.                   swap(max_cost[p], max_cost[q]);  
  104.             }  
  105.             vector <int> del;  
  106.             for (int x : st[q])  
  107.             {  
  108.                   if (st[p].find(x) != st[p].end()) del.push_back(x);  
  109.                   st[p].insert(x);  
  110.             }  
  111.             st[q].clear();  
  112.             par[q] = p;  
  113.             max_cost[p] = max(max_cost[p], max_cost[q]);  
  114.             max_cost[p] = max(w, max_cost[p]);  
  115.             for (int d : del)  
  116.             {  
  117.                   st[p].erase(d);  
  118.                   ans[d] = max_cost[p];  
  119.             }  
  120.       }  
  121.       for (int i = 1; i <= q; i++) cout << ans[i] << endl;  
  122. }  

Saturday, February 2, 2019

[UVA] 11987 - Almost Union-Find

Author            : Dipu Kumar Mohanto 
                    CSE, Batch - 6
                    BRUR.
Problem Statement : 11987 - Almost Union-Find
Source            : UVA Online Judge
Category          : Data Structure
Algorithm         : Disjoint Set Union
Verdict           : Accepted

  1. #include <bits/stdc++.h>  
  2.   
  3. using namespace std;  
  4.   
  5. static const int maxn = 3e5 + 5;  
  6.   
  7. struct node  
  8. {  
  9.     int ele, sum, father, ffather;  
  10.     node(int ele = 0, int sum = 0, int father = 0, int ffather) :  
  11.           ele(ele), sum(sum), father(father), ffather(ffather) {}  
  12. } ff[maxn];  
  13.   
  14. void makeSet(int n)  
  15. {  
  16.     for (int i = 1; i <= n; i++)  
  17.     {  
  18.         ff[i].ele = ff[n+i].ele = 1;  
  19.         ff[i].sum = ff[n+i].sum = i;  
  20.         ff[i].father = ff[n+i].father = n+i;  // father  
  21.     }  
  22. }  
  23.   
  24. int findRep(int r)  
  25. {  
  26.     if (ff[r].father == r) return ff[r].father;  
  27.     return ff[r].father = findRep(ff[r].father);  
  28. }  
  29.   
  30. void Union(int u, int v)  
  31. {  
  32.     int p = findRep(u);  
  33.     int q = findRep(v);  
  34.     if (p == q) return;  
  35.     ff[q].ele += ff[p].ele; ff[p].ele = 0;  
  36.     ff[q].sum += ff[p].sum; ff[p].sum = 0;  
  37.     ff[p].father = q;  
  38. }  
  39.   
  40. void Move(int u, int v)  
  41. {  
  42.     int p = findRep(u);  
  43.     int q = findRep(v);  
  44.     if (p == q) return;  
  45.     ff[q].ele += 1;  
  46.     ff[q].sum += u;  
  47.     ff[p].ele -= 1;  
  48.     ff[p].sum -= u;  
  49.     ff[u].father = q;  
  50. }  
  51.   
  52. void Res(int u)  
  53. {  
  54.     int p = findRep(u);  
  55.     printf("%d %d\n", ff[p].ele, ff[p].sum);  
  56. }  
  57.   
  58. int main()  
  59. {  
  60.     //freopen("in.txt", "r", stdin);  
  61.   
  62.     int n, q;  
  63.     while (scanf("%d %d", &n, &q) == 2)  
  64.     {  
  65.         makeSet(n);  
  66.         while (q--)  
  67.         {  
  68.             int type;  
  69.             scanf("%d", &type);  
  70.             if (type == 1)  
  71.             {  
  72.                 int u, v;  
  73.                 scanf("%d %d", &u, &v);  
  74.                 Union(u, v);  
  75.             }  
  76.             else if (type == 2)  
  77.             {  
  78.                 int u, v;  
  79.                 scanf("%d %d", &u, &v);  
  80.                 Move(u, v);  
  81.             }  
  82.             else if (type == 3)  
  83.             {  
  84.                 int u;  
  85.                 scanf("%d", &u);  
  86.                 Res(u);  
  87.             }  
  88.         }  
  89.     }  
  90. }