definitely great feeling

Aiming to reach specialist this contest!

it was worst

Close your eyes,what do you see?

In Codeforces, it is considered that you've not participated. So nothing happens.

In some platforms like AtCoder and Leetcode, if you've registered, then they'll consider your participation with 0 problems solved and you'll lose your rating.

To qualify as a trusted participant of the fourth division, you must: take part in at least five rated rounds (and solve at least one problem in each of them), do not have a point of 1400 or higher in the rating.

Only trusted participants are included in the official standings table, and their performance will be used for rating calculations for all rated participants. Therefore, if you are not a trusted participant, your performance will not be used for rating calculations in the round.

This can prevent certain users, such as those with alternative accounts, from disrupting the round since they are not trusted participants.

How can I become a tester too :(

Me too! Now I don't have to stress about negative delta... good luck not dropping to pupil haha.

Find the least value of x which satisfies the condition for some y(using binary search) then check while incrementing x check if it is a lattice point or not, if it is, ans+=4 as (all 4 quarants), else move to next value of y.

try with long long. i use long double it gave WA 7 after changing it long long i got AC

Your code may work slowly because you are using doubles although you don't need to, can you provide your full submission? based on your submission history you don't seem to have participated in this contest, quite weird.

Your bound on r for the binary search is wrong, since you have an array of size k + 1 and it is only k.

try cout<<tot_t + dis/speed<<" ";

which problem requires double?

It is.

if it's, someone please give us the idea and the source code if it's available

Count the number of positions i where s[i] != s[i+1]. Reduce the answer by 1 if there exists at least one position where s[i] equals 0 and s[i+1] equals 1.

count how many $$$groups$$$ of consecutive zeros and ones are present, this can be done by checking $$$s[i] != [i+1]$$$.

Then you have 3 cases:

• case 1 : you have more than 2 groups, the answer is always $$$groups-1$$$ ( you can always merge two groups together )

• case 2 : you have exactly to groups, either the two groups are in the correct order, so the answer is $$$1$$$, or they are in reverse order, so the answer is $$$2$$$.

• case 3 : you have exactly one group, so the answer is $$$1$$$.

There are many ways to solve this problem, and some of them are quite overthought. One can observe that the answer is $$$max(1, numberOfTransitionsFrom0to1) + numberOfTransitionsFrom1to0$$$. Code:

string s; cin >> s;
int cnt1 = 0, cnt2 = 0;
for (int i = 0; i < s.size()-1; i++) {
    if (s[i] == '1' and s[i+1] == '0') cnt1++;
    if (s[i] == '0' and s[i+1] == '1') cnt2++;
}
cout << max(1, cnt2) + cnt1 << "\n";

Consider each column. Since there’s only 3 rows, you must have at least two $$$1$$$ in the same column. From this, you can see that if there exists a $$$-1$$$ in a column, then you must force the other two to be $$$1$$$. You can build 2-SAT clauses with this thought. Then you can solve 2-sat using any $$$O(n)/O(n^2)$$$ SCC algorithm.

It's fixed now.

F: Binary search. Try to fix x = 1, 2, 3, 4, ... then find the range of corresponding y.

G: Group all elements which have the same bit in their binary representation when divided by 4, then sort them.

G: Since $$$a_i \oplus a_j \lt 4$$$ so there only $$$4$$$ values ($$$0, 1, 2, 3$$$). Let's call those values $$$c$$$. You can actually use dsu to merge $$$a_i$$$ and $$$c \oplus a_i$$$. But because these value is up to $$$10^9$$$. You can use a map to save $$$c \oplus a_i$$$'s index and merge their indices instead.

Here is my implementation: https://mirror.codeforces.com/contest/1971/submission/260443847

Use generators.

What if we just hardcode the right answers for all possible r?

What do you mean by "precision issues"?