Saturday, January 19, 2019

[Hackerearth] Make n00b_land Great Again!

Author            : Dipu Kumar Mohanto 
                    CSE, Batch - 6
                    BRUR.
Problem Statement : Make n00b_land Great Again!
Source            : Hackerearth
Category          : Data Structure, Search
Algorithm         : Parallel Binary Search
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.   
  58. using namespace __gnu_cxx;  
  59.   
  60. // rope <int> Rope;  
  61.   
  62. // int dr[] = {1, -1, 0, 0}; // 4 Direction  
  63. // int dc[] = {0, 0, 1, -1};  
  64. // int dr[] = {0, 0, 1, -1, 1, 1, -1, -1}; // 8 Direction  
  65. // int dc[] = {1, -1, 0, 0, 1, -1, 1, -1};  
  66. // int dr[] = {-1, 1, -2, -2, -1, 1, 2, 2}; // knight Moves  
  67. // int dc[] = {-2, -2, -1, 1, 2, 2, 1, -1};  
  68.   
  69. #define trace1(x)                           cerr << #x << ": " << x << endl;  
  70. #define trace2(x, y)                        cerr << #x << ": " << x << " | " << #y << ": " << y << endl;  
  71. #define trace3(x, y, z)                     cerr << #x << ": " << x << " | " << #y << ": " << y << " | " << #z << ": " << z << endl;  
  72. #define trace4(a, b, c, d)                  cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << endl;  
  73. #define trace5(a, b, c, d, e)               cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl;  
  74. #define trace6(a, b, c, d, e, f)            cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << " | " << #e << ": " << e << " | " << #f << ": " << f << endl;  
  75.   
  76. inline int setbit(int mask, int pos)        { return mask |= (1 << pos); }  
  77. inline int resetbit(int mask, int pos)      { return mask &= ~(1 << pos); }  
  78. inline int togglebit(int mask, int pos)     { return mask ^= (1 << pos); }  
  79. inline bool checkbit(int mask, int pos)     { return (bool)(mask & (1 << pos)); }  
  80.   
  81. #define popcount(mask)                       __builtin_popcount(mask) // count set bit  
  82. #define popcountLL(mask)                     __builtin_popcountll(mask) // for long long  
  83.   
  84. inline int read()                           { int a; scanf("%d", &a); return a; }  
  85. inline ll readLL()                          { ll a; scanf("%lld", &a); return a; }  
  86. inline double readDD()                      { double a; scanf("%lf", &a); return a; }  
  87.   
  88. template <typename T> string toString(T num) { stringstream ss; ss << num; return ss.str(); }  
  89. int toInt(string s)                          { int num; istringstream iss(s); iss >> num; return num;  }  
  90. ll toLLong(string s)                         { ll num; istringstream iss(s); iss >> num; return num; }  
  91.   
  92. #define inf             1e17  
  93. #define mod             1000000007  
  94.   
  95. static const int maxn = 5e5 + 5;  
  96. static const int logn = 20;  
  97.   
  98.   
  99. int tnode, towners, tquery;  
  100. vector <int> graph[maxn];  
  101. vector <int> owner[maxn];  
  102. vector <int> toCheck[maxn];  
  103. ll required[maxn];  
  104. int qn[maxn];  
  105. ll qx[maxn], qd[maxn]; 
  106. int lo[maxn], hi[maxn];  
  107. int N;   
  108. int depth[maxn], father[maxn][logn];  
  109. int subtreeSize[maxn];  
  110.   
  111. inline void dfs(int u = 1, int p = -1)  
  112. {  
  113.       FOR(i, logn-1) father[u][i] = father[ father[u][i-1] ][i-1];  
  114.       subtreeSize[u] = 1;  
  115.       FORI(v, graph[u])  
  116.       {  
  117.             if (v == p) continue;  
  118.             depth[v] = depth[u] + 1;  
  119.             father[v][0] = u;  
  120.             dfs(v, u);  
  121.             subtreeSize[u] += subtreeSize[v];  
  122.       }  
  123. }  
  124.   
  125. int chainHead[maxn], chainNo, chainInd[maxn],  
  126.     baseArray[maxn], posBase[maxn], ptr;  
  127.   
  128. inline void hld(int u = 1, int p = -1)  
  129. {  
  130.       if (chainHead[chainNo] == 0) chainHead[chainNo] = u;  
  131.       ptr++;  
  132.       baseArray[ptr] = 0;  
  133.       posBase[u] = ptr;  
  134.       chainInd[u] = chainNo;  
  135.       int mx = -1;  
  136.       int bigChild = -1;  
  137.       FORI(v, graph[u])  
  138.       {  
  139.             if (v == p) continue;  
  140.             if (subtreeSize[v] > mx) mx = subtreeSize[v], bigChild = v;  
  141.       }  
  142.       if (bigChild != -1) hld(bigChild, u);  
  143.       FORI(v, graph[u])  
  144.       {  
  145.             if (v == p || v == bigChild) continue;  
  146.             ++chainNo;  
  147.             hld(v, u);  
  148.       }  
  149. }  
  150.   
  151. struct tupple  
  152. {  
  153.       ll sumX, sumD, sumDD;  
  154.       tupple(ll x = 0, ll d = 0, ll dd = 0) : sumX(x), sumD(d), sumDD(dd) {}  
  155.   
  156.       inline void add(const tupple &tpl)  
  157.       {  
  158.             sumX += tpl.sumX;  
  159.             sumD += tpl.sumD;  
  160.             sumDD += tpl.sumDD;  
  161.       }  
  162. };  
  163.   
  164. tupple BTree[maxn];  
  165.   
  166. inline void update(int pos, tupple val)  
  167. {  
  168.       while (pos <= N)  
  169.       {  
  170.             BTree[pos].add(val);  
  171.             pos += (pos & -pos);  
  172.       }  
  173. }  
  174.   
  175. inline tupple query(int pos)  
  176. {  
  177.       tupple tpl = tupple();  
  178.       while (pos > 0)  
  179.       {  
  180.             tpl.add(BTree[pos]);  
  181.             pos -= (pos & -pos);  
  182.       }  
  183.       return tpl;  
  184. }  
  185.   
  186. inline tupple getSum(int l, int r)  
  187. {  
  188.       tupple Left = query(l-1);  
  189.       tupple Right = query(r);  
  190.       tupple ans = tupple();  
  191.       ans.sumX = Right.sumX - Left.sumX;  
  192.       ans.sumD = Right.sumD - Left.sumD;  
  193.       ans.sumDD = Right.sumDD - Left.sumDD;  
  194.       return ans;  
  195. }  
  196.   
  197. inline tupple query_path(int u, int v)  
  198. {  
  199.       tupple res = tupple();  
  200.       int uChain;  
  201.       int vChain = chainInd[v];  
  202.       while (true)  
  203.       {  
  204.             uChain = chainInd[u];  
  205.             if (uChain == vChain)  
  206.             {  
  207.                   int l = posBase[v];  
  208.                   int r = posBase[u];  
  209.                   assert(l <= r);  
  210.                   tupple q = getSum(l, r);  
  211.                   res.add(q);  
  212.                   break;  
  213.             }  
  214.             int l = posBase[ chainHead[uChain] ];  
  215.             int r = posBase[u];  
  216.             assert(l <= r);  
  217.             tupple q = getSum(l, r);  
  218.             res.add(q);  
  219.             u = father[ chainHead[uChain] ][0];  
  220.       }  
  221.       return res;  
  222. }  
  223.   
  224. inline void update_hld(int nodeInd)  
  225. {  
  226.       int node = qn[nodeInd];  
  227.       ll x = qx[nodeInd];  
  228.       ll d = qd[nodeInd];  
  229.       ll dd = depth[node] * d * 1LL;  
  230.       int pos = posBase[node];  
  231.       update(pos, tupple(x, d, dd));  
  232. }  
  233.   
  234. inline void recover(int nodeInd)  
  235. {  
  236.       int node = qn[nodeInd];  
  237.       ll x = qx[nodeInd];  
  238.       ll d = qd[nodeInd];  
  239.       ll dd = depth[node] * d * 1LL;  
  240.       int pos = posBase[node];  
  241.       update(pos, tupple(-x, -d, -dd));  
  242. }  
  243.   
  244. int main()  
  245. {  
  246.       //FI;  
  247.       tnode = read();  
  248.       towners = read();  
  249.       REP(v, 2, tnode)  
  250.       {  
  251.             int u = read();  
  252.             graph[u].eb(v);  
  253.       }  
  254.       FOR(i, tnode)  
  255.       {  
  256.             int own = read();  
  257.             owner[own].eb(i);  
  258.       }  
  259.       FOR(i, towners) required[i] = readLL();  
  260.       tquery = read();  
  261.       FOR(i, tquery)  
  262.       {  
  263.             qn[i] = read();  
  264.             qx[i] = readLL();  
  265.             qd[i] = readLL();  
  266.       }  
  267.       depth[1] = 1;  
  268.       dfs();  
  269.       hld();  
  270.       N = ptr;  
  271.       FOR(i, towners) lo[i] = 1, hi[i] = tquery+1;  
  272.       while (true)  
  273.       {  
  274.             FOR(i, N) BTree[i] = tupple();  
  275.             bool updateRqd = false;  
  276.             int maxq = -1;  
  277.             FOR(i, towners)  
  278.             {  
  279.                   if (lo[i] != hi[i])  
  280.                   {  
  281.                         updateRqd = true;  
  282.                         int mid = (lo[i] + hi[i]) / 2;  
  283.                         if (mid > maxq) maxq = mid;  
  284.                         toCheck[mid].eb(i);  
  285.   
  286.                   }  
  287.             }  
  288.             if (updateRqd == falsebreak;  
  289.             FOR(qq, maxq)  
  290.             {  
  291.                   update_hld(qq);  
  292.                   FORI(id, toCheck[qq])  
  293.                   {  
  294.                         ll sum = 0;  
  295.                         FORI(u, owner[id])  
  296.                         {  
  297.                               tupple qry = query_path(u, 1);  
  298.                               ll sum_x = qry.sumX;  
  299.                               ll sum_d = qry.sumD;  
  300.                               ll sum_dd = qry.sumDD;  
  301.                               ll add = depth[u] * sum_d * 1LL;  
  302.                               sum = sum + sum_x + add - sum_dd;  
  303.                               if (sum >= required[id]) break;  
  304.                         }  
  305.                         if (sum >= required[id]) hi[id] = qq;  
  306.                         else lo[id] = qq + 1;  
  307.                   }  
  308.                   toCheck[qq].clear();  
  309.             }  
  310.       }  
  311.       FOR(i, towners)  
  312.       {  
  313.             if (lo[i] <= tquery) printf("%d\n", lo[i]);  
  314.             else puts("rekt");  
  315.       }  
  316. }  

No comments:

Post a Comment

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