Monday, January 21, 2019

[HDU] 5306 - Gorgeous Sequence

Author            : Dipu Kumar Mohanto 
                    CSE, Batch - 6
                    BRUR.
Problem Statement : 5306 - Gorgeous Sequence 
Source            : HDU
Category          : Data Structure
Algorithm         : Segment Tree Beats
Verdict           : Accepted

  1. #include "bits/stdc++.h"  
  2.   
  3. using namespace std;  
  4.   
  5. #define FI              freopen("in.txt", "r", stdin)  
  6. #define FO              freopen("out.txt", "w", stdout)  
  7. #define FAST            ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)  
  8.   
  9. #define FOR(i, n)       for (int i = 1; i <= n; i++)  
  10. #define For(i, n)       for (int i = 0; i < n; i++)  
  11. #define ROF(i, n)       for (int i = n; i >= 1; i--)  
  12. #define Rof(i, n)       for (int i = n-1; i >= 0; i--)  
  13. #define FORI(i, n)      for (auto i : n)  
  14. #define REP(i, a, b)    for (int i = a; i <= b; i++)  
  15.   
  16. #define ll              long long  
  17. #define ull             unsigned long long  
  18. #define vi              vector <int>  
  19. #define vl              vector <ll>  
  20. #define pii             pair <int, int>  
  21. #define pll             pair <ll, ll>  
  22. #define mk              make_pair  
  23. #define ff              first  
  24. #define ss              second  
  25. #define eb              emplace_back  
  26. #define em              emplace  
  27. #define pb              push_back  
  28. #define ppb             pop_back  
  29. #define All(a)          a.begin(), a.end()  
  30. #define memo(a, b)      memset(a, b, sizeof a)  
  31. #define Sort(a)         sort(All(a))  
  32. #define ED(a)           Sort(a), a.erase(unique(All(a)), a.end())  
  33. #define rev(a)          reverse(All(a))  
  34. #define sz(a)           (int)a.size()  
  35. #define max3(a, b, c)   max(a, max(b, c))  
  36. #define min3(a, b, c)   min(a, min(b, c))  
  37. #define maxAll(a)       *max_element(All(a))  
  38. #define minAll(a)       *min_element(All(a))  
  39. #define allUpper(a)     transform(All(a), a.begin(), :: toupper)  
  40. #define allLower(a)     transform(All(a), a.begin(), :: tolower)  
  41. #define endl            '\n'  
  42. #define nl              puts("")  
  43. #define ub              upper_bound  
  44. #define lb              lower_bound  
  45. #define Exp             exp(1.0)  
  46. #define PIE             2*acos(0.0)  
  47. #define Sin(a)          sin(((a)*PIE)/180.0)  
  48. #define EPS             1e-9  
  49.   
  50. #include "ext/pb_ds/assoc_container.hpp"  
  51. #include "ext/pb_ds/tree_policy.hpp"  
  52. using namespace __gnu_pbds;  
  53.   
  54. template <typename T> using orderset = tree <T, null_type, less <T>, rb_tree_tag, tree_order_statistics_node_update>;  
  55.   
  56. #include "ext/rope"  
  57. using namespace __gnu_cxx;  
  58.   
  59. // rope <int> Rope;  
  60.   
  61. // int dr[] = {1, -1, 0, 0}; // 4 Direction  
  62. // int dc[] = {0, 0, 1, -1};  
  63. // int dr[] = {0, 0, 1, -1, 1, 1, -1, -1}; // 8 Direction  
  64. // int dc[] = {1, -1, 0, 0, 1, -1, 1, -1};  
  65. // int dr[] = {-1, 1, -2, -2, -1, 1, 2, 2}; // knight Moves  
  66. // int dc[] = {-2, -2, -1, 1, 2, 2, 1, -1};  
  67.   
  68. #define trace1(x)                           cerr << #x << ": " << x << endl;  
  69. #define trace2(x, y)                        cerr << #x << ": " << x << " | " << #y << ": " << y << endl;  
  70. #define trace3(x, y, z)                     cerr << #x << ": " << x << " | " << #y << ": " << y << " | " << #z << ": " << z << endl;  
  71. #define trace4(a, b, c, d)                  cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << endl;  
  72. #define trace5(a, b, c, d, e)               cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl;  
  73. #define trace6(a, b, c, d, e, f)            cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << " | " << #e << ": " << e << " | " << #f << ": " << f << endl;  
  74.   
  75. inline int setbit(int mask, int pos)        { return mask |= (1 << pos); }  
  76. inline int resetbit(int mask, int pos)      { return mask &= ~(1 << pos); }  
  77. inline int togglebit(int mask, int pos)     { return mask ^= (1 << pos); }  
  78. inline bool checkbit(int mask, int pos)     { return (bool)(mask & (1 << pos)); }  
  79.   
  80. #define popcount(mask)                       __builtin_popcount(mask) // count set bit  
  81. #define popcountLL(mask)                     __builtin_popcountll(mask) // for long long  
  82.   
  83. inline int read()                           { int a; scanf("%d", &a); return a; }  
  84. inline ll readLL()                          { ll a; scanf("%lld", &a); return a; }  
  85. inline double readDD()                      { double a; scanf("%lf", &a); return a; }  
  86.   
  87. template <typename T> string toString(T num) { stringstream ss; ss << num; return ss.str(); }  
  88. int toInt(string s)                          { int num; istringstream iss(s); iss >> num; return num;  }  
  89. ll toLLong(string s)                         { ll num; istringstream iss(s); iss >> num; return num; }  
  90.   
  91. #define inf             1e17  
  92. #define mod             1000000007  
  93.   
  94. static const int maxn = 1e6 + 5;  
  95. static const int logn = 18;  
  96.   
  97.   
  98. struct segmentTreeBeats  
  99. {  
  100.       ll max1, max2, cnt_max1, sum;  
  101.       segmentTreeBeats(ll max1 = 0, ll max2 = 0, ll cnt_max1 = 0, ll sum = 0) :  
  102.             max1(max1), max2(max2), cnt_max1(cnt_max1), sum(sum) {}  
  103. } Tree[maxn << 2];  
  104.   
  105. ll arr[maxn];  
  106.   
  107. inline void push_up(int node)  
  108. {  
  109.       int lft = node << 1;  
  110.       int rgt = lft | 1;  
  111.       segmentTreeBeats &par = Tree[node];  
  112.       segmentTreeBeats &lchild = Tree[lft];  
  113.       segmentTreeBeats &rchild = Tree[rgt];  
  114.       par.max1 = max(lchild.max1, rchild.max1);  
  115.       par.sum = lchild.sum + rchild.sum;  
  116.       if (lchild.max1 == rchild.max1)  
  117.       {  
  118.             par.cnt_max1 = lchild.cnt_max1 + rchild.cnt_max1;  
  119.             par.max2 = max(lchild.max2, rchild.max2);  
  120.       }  
  121.       else  
  122.       {  
  123.             if (lchild.max1 > rchild.max1) par.cnt_max1 = lchild.cnt_max1;  
  124.             else par.cnt_max1 = rchild.cnt_max1;  
  125.             par.max2 = max(min(lchild.max1, rchild.max1), max(lchild.max2, rchild.max2));  
  126.       }  
  127. }  
  128.   
  129. inline void modify(int node, ll val)  
  130. {  
  131.       segmentTreeBeats &par = Tree[node];  
  132.       if (val >= par.max1) return;  
  133.       par.sum -= (par.max1 - val) * par.cnt_max1;  
  134.       par.max1 = val;  
  135. }  
  136.   
  137. inline void push_down(int node)  
  138. {  
  139.       int lft = node << 1;  
  140.       int rgt = lft | 1;  
  141.       modify(lft, Tree[node].max1);  
  142.       modify(rgt, Tree[node].max1);  
  143. }  
  144.   
  145. inline void build(int node, int a, int b)  
  146. {  
  147.       if (a == b)  
  148.       {  
  149.             Tree[node] = segmentTreeBeats(arr[a], -1, 1, arr[a]);  
  150.             return;  
  151.       }  
  152.       int lft = node << 1;  
  153.       int rgt = lft | 1;  
  154.       int mid = (a + b) >> 1;  
  155.       build(lft, a, mid);  
  156.       build(rgt, mid+1, b);  
  157.       push_up(node);  
  158. }  
  159.   
  160. inline void update(int node, int a, int b, int i, int j, ll val)  
  161. {  
  162.       if (a > j || b < i || Tree[node].max1 <= val) return;  
  163.       if (a >= i && b <= j && Tree[node].max2 < val)  
  164.       {  
  165.             modify(node, val);  
  166.             return;  
  167.       }  
  168.       push_down(node);  
  169.       int lft = node << 1;  
  170.       int rgt = lft | 1;  
  171.       int mid = (a + b) >> 1;  
  172.       update(lft, a, mid, i, j, val);  
  173.       update(rgt, mid+1, b, i, j, val);  
  174.       push_up(node);  
  175. }  
  176.   
  177. inline ll get_max(int node, int a, int b, int i, int j)  
  178. {  
  179.       if (a == i && b == j) return Tree[node].max1;  
  180.       push_down(node);  
  181.       int lft = node << 1;  
  182.       int rgt = lft | 1;  
  183.       int mid = (a + b) >> 1;  
  184.       ll res = -1;  
  185.       if (j <= mid)  
  186.       {  
  187.             res = max(res, get_max(lft, a, mid, i, j));  
  188.       }  
  189.       else if (i > mid)  
  190.       {  
  191.             res = max(res, get_max(rgt, mid+1, b, i, j));  
  192.       }  
  193.       else  
  194.       {  
  195.             ll p = get_max(lft, a, mid, i, mid);  
  196.             ll q = get_max(rgt, mid+1, b, mid+1, j);  
  197.             res = max(res, max(p, q));  
  198.       }  
  199.       push_up(node);  
  200.       return res;  
  201. }  
  202.   
  203. inline ll get_sum(int node, int a, int b, int i, int j)  
  204. {  
  205.       if (a == i && b == j) return Tree[node].sum;  
  206.       push_down(node);  
  207.       int lft = node << 1;  
  208.       int rgt = lft | 1;  
  209.       int mid = (a + b) >> 1;  
  210.       ll res = 0;  
  211.       if (j <= mid)  
  212.       {  
  213.             res += get_sum(lft, a, mid, i, j);  
  214.       }  
  215.       else if (i > mid)  
  216.       {  
  217.             res += get_sum(rgt, mid+1, b, i, j);  
  218.       }  
  219.       else  
  220.       {  
  221.             res += get_sum(lft, a, mid, i, mid);  
  222.             res += get_sum(rgt, mid+1, b, mid+1, j);  
  223.       }  
  224.       push_up(node);  
  225.       return res;  
  226. }  
  227.   
  228. int main()  
  229. {  
  230.       FI;  
  231.       int tc = read();  
  232.       FOR(tcase, tc)  
  233.       {  
  234.             int n = read();  
  235.             int q = read();  
  236.             FOR(i, n) arr[i] = read();  
  237.             build(1, 1, n);  
  238.             FOR(_q, q)  
  239.             {  
  240.                   int type = read();  
  241.                   int l = read();  
  242.                   int r = read();  
  243.                   if (l > r) swap(l, r);  
  244.                   if (type == 0)  
  245.                   {  
  246.                         ll x = readLL();  
  247.                         update(1, 1, n, l, r, x);  
  248.                   }  
  249.                   else if (type == 1)  
  250.                   {  
  251.                         ll maxi = get_max(1, 1, n, l, r);  
  252.                         printf("%lld\n", maxi);  
  253.                   }  
  254.                   else  
  255.                   {  
  256.                         ll sum = get_sum(1, 1, n, l, r);  
  257.                         printf("%lld\n", sum);  
  258.                   }  
  259.             }  
  260.       }  
  261. }  

No comments:

Post a Comment

Note: Only a member of this blog may post a comment.