As a writer, Getaway_Car orzzzzz!

As a tester, Getaway_Car orzzzzz!

As a cwOIer, Getaway_Car orzzzzz!

As a contestant, Getaway_Car orzzzzz!

As a newbie, Getaway_Car orzzzzz!

As a (tester),Getaway_Car orzzzzz!

As a AHOIer, Getaway_Car orzzzzz!

As a !tester && !writer && participation, Getaway_Car orzzzzz!

edit: bro????? i did nothing to deserve that downvotes????? if you dont like my comment why dont you move on and leave mine????????

As a tester, Getaway_Car orzzzzz!

As a newbie, Getaway_car orzzzzz!

As a newbie, Getaway_Car orzzzzz!

As a newbie, Getaway_Car orzzzzz!

As a former cwOIer, Getaway_Car orzzzzz!

As a tester, I was purple when I test :(

Oh but I have to attend ABC on 20:00 $$$Q\omega Q$$$

其实我也是中国的 但是我"TLE"了"TLE" means time limit enough

yeah

67

as a tester, i dont remember testing

As a contestant, I hope it'll be a great CSP implementation contest :D

Good luck

Good luck!

Great wish

bro go to contests on top of the main page and register the first red register icon

Go to the nearest registration office in your area

Ok

Bing chilling

yes

It happened! 1129 div2 will always be special for me :)

If we go ahead at the usual time, it will conflict with COCI

great round

As a participant, lrb828281 dsa dsasa dsasasa

As a participant, lrb828281 dsa dsasa dsasasa

I’ve read them and I agree.

Here is my code:

1   #include <bits/stdc++.h>
  1
  2 using namespace std;
  3
  4 long long D[61] = {0, 0, 1, 3, 5, 7, 11, 17, 21, 29, 33, 41, 53, 61, 75, 91, 105, 115, 133, 147, 171, 187, 211, 233, 249, 271, 289, 327, 353, 379, 409, 427, 46    3, 493, 527, 555, 611, 645, 677, 717, 749, 785, 823, 869, 913, 951, 999, 1033, 1081, 1153, 1197, 1235, 1293, 1343, 1401, 1451, 1497, 1551, 1609, 1679, 1731};
  5 long long P[61] = {0, 1, 6, 24, 76, 220, 606, 1612, 4158, 10482, 25866, 62692, 149526, 351716, 817362, 1879520, 4282058, 9676688, 21710796, 48400096, 107283238    , 236583310, 519300176, 136820651, 474962826, 371105961, 616376335, 49951329, 863257431, 526934377, 189831495, 723584179, 289527242, 562262698, 696690249, 7474    39775, 622443848, 338894318, 543542652, 181080058, 269836323, 799645219, 13719665, 631195792, 37230596, 744717670, 86874645, 866645875, 132641236, 75253961, 80    1733003, 975460330, 826925938, 668089391, 890807927, 948390927, 345304740, 812267539, 331051740, 990929756, 485065574};
  6
  7 long long sumationShit(long long num) {
  8         if (num < 1) {
  9                 return 0;
 10         }
 11         int m = 0;
 12         while ((1LL << m) &mdash; 1 < num) {
 13                 m++;
 14         }
 15
 16         long long lo = 1LL << (m &mdash; 1);
 17         long long hi = (1LL << m) &mdash; 1;
 18         long long cut = hi &mdash; D[m];
 19
 20         long long ans = P[m &mdash; 1];
 21         long long c1 = min(num, cut &mdash; 1) &mdash; lo + 1;
 22         if (c1 > 0) {
 23                 ans += c1 % 998244353 * m + sumationShit(c1 + 1) &mdash; sumationShit(1);
 24         }
 25
 26         if (num >= cut) {
 27                 long long c2 = num &mdash; cut + 1;
 28                 ans += c2 * m + (D[m] + hi &mdash; num) * c2 / 2;
 29         }
 30
 31         return ans % 998244353;
 32 }
 33
 34
 35 int main() {
 36         ios::sync_with_stdio(false);
 37         cin.tie(nullptr);
 38
 39         int t;
 40         cin >> t;
 41         while (t--) {
 42                 long long l, r;
 43                 cin >> l >> r;
 44                 long long lAns, rAns;
 45                 long long ans;
 46
 47                 lAns = sumationShit(l &mdash; 1);
 48                 rAns = sumationShit(r);
 49
 50                 ans = rAns &mdash; lAns;
 51                 ans = (ans % 998244353 + 998244353) % 998244353;
 52
 53                 cout << ans << "\n";
 54
 55         }
 56
 57         return 0;
 58 }

The main idea is that a num can be computes as either doing op1 until the highest bit is set and then deleting until you get the correct bits or just adding the bits one by one (you can add bit k, by doing op 1 k times and then doing op 1 again, this will put k and only k as 1) the main idea here is that:

doing it the first way takes m + d (m times op 1, d times op 2) second way is m + f(n — 2^(m-1)), (you can think of this as just putting that bit there and then doing the rest of the bits, which I defined recursively)

if you put these together than deleting is cheaper when d <= f(r),

then effectively we can precompute the amount of numbers for each range of [2^k, 2^(k+1)) that will be cheaper to do in the first way, and that will be cheaper to do in the second way.

then you compute for each for each bit block the total cost.

tbh reading my explanation it makes it way more complex than it really is, I suggest you play around with the bit values of the numbers on paper, the core idea is kinda obvious once you get the hang of it, and the rest is just algebraic bullshitery.

oh and the numbers that are cheaper to delete are all part of a suffix, so you essentially use prefix sums for that, same for low and high, its all prefix sums.

Hints for E:

• Root the tree at node 1. We'll perform two phases.
• In the first phase, use $$$(n - 1)$$$ queries to determine the subtree size of every non-root node $$$u$$$.
• For the second phase, make the following observation: if you sort the nodes of a rooted tree in decreasing order of subtree size, then the parent of every node lies strictly before it in this order. Try to build the tree one edge at a time by going across nodes in this order (when you encounter a node, try to find its parent from the preceding nodes), and using the same idea as in the first phase.

B and A shoulve been switched tbh.

D2 is pretty simple at its core (at least for the amount of points you woulve gotten from it), i did a small explenation for aditya. But holy shit the amount of off my one errors drove me nuts lol.

The process of checking whether a subsequence is good does not affect the original array

Choose $$$b = [2, 1, 1, 0, 3]$$$

There is already an element 0, therefore, after any operations, there is at least one zero left in $$$b$$$, therefore, the original subsequence is already good.

Did you not feel anything like shame while writing this comment? Or does the very 80 IQ that compels you to cheat (I doubt you could even solve 2C on your own) also make it impossible for you to harbour complex human emotions like guilt and shame?

you are everything that is wrong with todays codeforces, you want everyone to think you are so smart for solving these when in reality you are just using ai even you comments seem ai writen go kys you ai trash

Just a intuitive idea, I think it might be using digit dp, or there might be some observations.

Btw, the problem ask you to modulo 998244353, overflowing shouldn't be a problem

"Back in the day" unc :sob: