Friday, January 25, 2019

[toph.co] Another Update-Query Problem

Author            : Dipu Kumar Mohanto 
                    CSE, Batch - 6
                    BRUR.
Problem Statement : Another Update-Query Problem
Source            : toph.co
Category          : Data Structure
Algorithm         : Segment Tree, Lazy Propagation
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             1e7  
  92. #define mod             1000000007  
  93.   
  94. static const int maxn = 2e5 + 5;  
  95. static const int logn = 21;  
  96.   
  97. struct segmentTree  
  98. {  
  99.       ll lazy, sum1, sum2;  
  100.       segmentTree(ll lazy = 0, ll sum1 = 0, ll sum2 = 0) :  
  101.             lazy(lazy), sum1(sum1), sum2(sum2) {}  
  102.   
  103.       inline void add(const segmentTree &p)  
  104.       {  
  105.             sum1 = (sum1 + p.sum1) % mod;  
  106.             sum2 = (sum2 + p.sum2) % mod;  
  107.       }  
  108. } Tree[maxn << 2];  
  109.   
  110. inline ll getSum(ll n)  
  111. {  
  112.       if (n <= 0) return 0;  
  113.       ll sum = (n * (n + 1)) % mod;  
  114.       sum = (sum * 500000004 * 1LL) % mod;  
  115.       return sum;  
  116. }  
  117.   
  118. inline void updateLazy(int node, int a, int b, ll lazy)  
  119. {  
  120.       ll man = ((b - a + 1) * lazy * 1LL) % mod;  
  121.       Tree[node].sum1 = (Tree[node].sum1 + man) % mod;  
  122.       ll val = (getSum(b) - getSum(a-1) + mod) % mod;  
  123.       val = (val * lazy * 1LL) % mod;  
  124.       Tree[node].sum2 = (Tree[node].sum2 + val) % mod;  
  125.       Tree[node].lazy = (Tree[node].lazy + lazy) % mod;  
  126. }  
  127.   
  128. inline void updateNode(int node, int a, int b)  
  129. {  
  130.       int lft = node << 1;  
  131.       int rgt = lft | 1;  
  132.       int mid = (a + b) >> 1;  
  133.       ll lazy = Tree[node].lazy;  
  134.       ll man = ((mid - a + 1) * lazy * 1LL) % mod;  
  135.       Tree[lft].sum1 = (Tree[lft].sum1 + man) % mod;  
  136.       ll val = (getSum(mid) - getSum(a-1) + mod) % mod;  
  137.       val = (val * lazy * 1LL) % mod;  
  138.       Tree[lft].sum2 = (Tree[lft].sum2 + val) % mod;  
  139.       Tree[lft].lazy = (Tree[lft].lazy + lazy) % mod;  
  140.       man = ((b - mid) * lazy * 1LL) % mod;  
  141.       Tree[rgt].sum1 = (Tree[rgt].sum1 + man) % mod;  
  142.       val = (getSum(b) - getSum(mid) + mod) % mod;  
  143.       val = (val * lazy * 1LL) % mod;  
  144.       Tree[rgt].sum2 = (Tree[rgt].sum2 + val) % mod;  
  145.       Tree[rgt].lazy = (Tree[rgt].lazy + lazy) % mod;  
  146.   
  147.       Tree[node].lazy = 0;  
  148. }  
  149.   
  150. inline void marge(int node)  
  151. {  
  152.       int lft = node << 1;  
  153.       int rgt = lft | 1;  
  154.       Tree[node].sum1 = (Tree[lft].sum1 + Tree[rgt].sum1) % mod;  
  155.       Tree[node].sum2 = (Tree[lft].sum2 + Tree[rgt].sum2) % mod;  
  156. }  
  157.   
  158. ll arr[maxn];  
  159.   
  160. inline void build(int node, int a, int b)  
  161. {  
  162.       if (a == b)  
  163.       {  
  164.             Tree[node].lazy = 0;  
  165.             Tree[node].sum1 = arr[a];  
  166.             Tree[node].sum2 = ((ll)a * arr[a]) % mod;  
  167.             return;  
  168.       }  
  169.       int lft = node << 1;  
  170.       int rgt = lft | 1;  
  171.       int mid = (a + b) >> 1;  
  172.       build(lft, a, mid);  
  173.       build(rgt, mid+1, b);  
  174.       marge(node);  
  175. }  
  176.   
  177. inline void update(int node, int a, int b, int i, int j, ll x)  
  178. {  
  179.       if (a == i && b == j)  
  180.       {  
  181.             updateLazy(node, a, b, x);  
  182.             return;  
  183.       }  
  184.       if (Tree[node].lazy > 0)  
  185.       {  
  186.             updateNode(node, a, b);  
  187.       }  
  188.       int lft = node << 1;  
  189.       int rgt = lft | 1;  
  190.       int mid = (a + b) >> 1;  
  191.       if (j <= mid)  
  192.       {  
  193.             update(lft, a, mid, i, j, x);  
  194.       }  
  195.       else if (i > mid)  
  196.       {  
  197.             update(rgt, mid+1, b, i, j, x);  
  198.       }  
  199.       else  
  200.       {  
  201.             update(lft, a, mid, i, mid, x);  
  202.             update(rgt, mid+1, b, mid+1, j, x);  
  203.       }  
  204.       marge(node);  
  205. }  
  206.   
  207. inline segmentTree query(int node, int a, int b, int i, int j)  
  208. {  
  209.       if (a == i && b == j)  
  210.       {  
  211.             return Tree[node];  
  212.       }  
  213.       if (Tree[node].lazy > 0)  
  214.       {  
  215.             updateNode(node, a, b);  
  216.       }  
  217.       int lft = node << 1;  
  218.       int rgt = lft | 1;  
  219.       int mid = (a + b) >> 1;  
  220.       segmentTree res = segmentTree();  
  221.       if (j <= mid)  
  222.       {  
  223.             segmentTree p = query(lft, a, mid, i, j);  
  224.             res.add(p);  
  225.       }  
  226.       else if (i > mid)  
  227.       {  
  228.             segmentTree q = query(rgt, mid+1, b, i, j);  
  229.             res.add(q);  
  230.       }  
  231.       else  
  232.       {  
  233.             segmentTree p = query(lft, a, mid, i, mid);  
  234.             segmentTree q = query(rgt, mid+1, b, mid+1, j);  
  235.             res.add(p);  
  236.             res.add(q);  
  237.       }  
  238.       marge(node);  
  239.       return res;  
  240. }  
  241.   
  242. int main()  
  243. {  
  244.       //FI;  
  245.       int tc = read();  
  246.       FOR(tcase, tc)  
  247.       {  
  248.             int n = read();  
  249.             int q = read();  
  250.             FOR(i, n) arr[i] = readLL();  
  251.             build(1, 1, n);  
  252.             printf("Case %d:\n", tcase);  
  253.             while (q--)  
  254.             {  
  255.                   int type = read();  
  256.                   if (type == 1)  
  257.                   {  
  258.                         int l = read();  
  259.                         int r = read();  
  260.                         ll x = readLL();  
  261.                         assert(l <= r);  
  262.                         update(1, 1, n, l, r, x);  
  263.                   }  
  264.                   else  
  265.                   {  
  266.                         int l = read();  
  267.                         int r = read();  
  268.                         ll d = readLL();  
  269.                         d %= mod;  
  270.                         assert(l <= r);  
  271.                         segmentTree res = query(1, 1, n, l, r);  
  272.                         ll suma = res.sum1 % mod;  
  273.                         assert(suma >= 0);  
  274.                         ll bad = (l * suma * 1LL) % mod;  
  275.                         ll bad2 = (res.sum2 - bad + mod) % mod;  
  276.                         ll sumd = (d * bad2 * 1LL) % mod;  
  277.                         assert(sumd >= 0);  
  278.                         ll ans = (suma + sumd) % mod;  
  279.                         printf("%lld\n", ans);  
  280.                   }  
  281.             }  
  282.             FOR(i, n) arr[i] = 0;  
  283.             For(i, maxn*4) Tree[i] = segmentTree();  
  284.       }  
  285. }  

No comments:

Post a Comment

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