It is very friendly to East Asian players, I hope it will be more than a few times . We don't need to stay up till 2 a.m. to sleep.QWQ

Why ?

Yes ! very good !!!

Hmm...I think it's not as easy as you think

And your contribution will decrease.

Yes of course "School in Sunday"

Some people also have school during the usual contest time.

For Chinese and Japanese，this tmie is better than usual time, as the usual time is 10：35~01:05 in Peking, China.

[deleted]

Same too, good luck.

Due to universities mid exams I guess !!

In China we have to stay up until 2am to participate in contests with usual times :(

The game I said refers to playing codeforces. Please don't get me wrong

I tried to use inclusion-exclusion principle. The answer is (different a) + (different b) — (different a and b). I have figure out how to calculate "different a" and "different b", but didn't figure out how to calculate "different a and b".

I calculated the total possible solutions which will be nC3 and then subtracted the number of bad combinations(observe that in a bad combination 2 problems will be having the same topic type and 2 problems will be having the same difficulty).

Try to calculate the number of bad combinations and then it's trivial.

with dp. the main point is for each flip you just have to update O(n) dp values which makes it O(nq) that fits in time limit

There is a technique know in Brazil as Color Update, it consists in store in a set intervals that we assign a given color, each position can have at most one color. You can use this idea to color an interval, ask the maximal interval of the same color that contains a given point, etc. Using this idea just build maximal staircases, for each position store in which maximal staircases it is, and in which position. Then using Color Update technique the solution is straightforward.

just find cases where the given condition fails and remove it from total cases

Inclusion and Exclusion Principle, the total number we can get without any constrains is (N choose 3), then we subtract the invalid ones.

the invalid ones must have 2 similar elements in both sides so we just count that.

https://mirror.codeforces.com/contest/1598/submission/131438774

Definitely missing something. $$$D$$$ was a nice exercise of complement counting. I solved it by adding edges $$$a[i], b[i]$$$ to empty bipartite graph with $$$2$$$ partite sets of size $$$n$$$ and then the problem becomes equivalent to counting the number of paths with $$$3$$$ edges in this graph.(at this point the problem is quite easy by storing frequency array of both $$$a$$$ and $$$b$$$) Of course this is only for better visualization. In reality you never actually do a graph algorithm to solve the problem. But I personally found this as a nice way to see the problem.

You are not alone.

There are so many comments in your code :-\

Very suspicious submission.

You seem to be a Cheater

you are not going to see any rating change.

You piece of shit. Look into the mirror and ask yourself what have you gained from cheating. You are a disgrace. Your parents will be ashamed of you.

Someone, Please hack this cheater's solution The same copied codes by others are hacked by many people

https://mirror.codeforces.com/contest/1598/submission/131456342 it worked with c++

I used the exact same approach as you did, and got AC in java. 131438128 I am pretty sure that your issue is at the line where you create a new ArrayList (computeIfAbsent). Try to change that to putIfAbsent and it should work fine.

I guess you checked for $$$sum \cdot (n-2)=(sum-a_1-a_2)\cdot n$$$?

Notice, that you can shorten this check to $$$2 \cdot sum = a_1 n + a_2 n$$$ for which both sides do fit in a long long.

int64 works fine for C. You just need to reduce the equation with algebra.

Let be ai = task, notice, that for a we can take (n * (n — 1) / 2) other tasks and lets just remove pairs of tasks that we can not use with a. This is the amount of the same difficulty * the amount of the same topic

If we consider pairs as coordinates on 2D plane and since all points are distinct, only way three points selected at random dis-satisfy the given conditions is when they form the right angle triangle. Hence subtract number of right angle triangles from NC3.

You can hack other's submissions. Hacking doesn't earn or loss points in this contest. Feel free to hack if you find any bugs in other's code.

D was combinations problem though looks like graph

why u didnt check examples?

overflow.

sum can be at max 2e5 * 1e9 == 2e14

And then sum*n==2e14*2e5 == 4e19 which is more than the limit of the long data type

I don't think this is wrong, maybe its an overflow issue

bro power will reach to something 10^20 and long long has range 10^18

The fact is that there are many Chinese top coders like Miracle03 and QAQAutoMaton are busy in teaching some new coders.So they don't have time to write more contests.The rounds you see are written by some students who love coding , and I think they're good enough for these younger coders.I think they need more encouragement but not prejudice.

I do hope you could post comments with less discrimination and prejudice.And I think Chinese writers can get progress very soon.Best wish.

Oh, i mean that you can start only 4 staircases at each free cell

May be after hacking phase is finished

F has too many details :( Is it only for me?

There are only 5 days. We can enumerate all pairs of days and find if it is possible to seperate students into two groups. Let's say we choose day A and day B. If there are some students (possibly one) who can't attend day A and day B, then {A, B} isn't the answer. We count the students who can only attend at day A, students who can only attend at day B, and students who can attend at both day A and B.

void solve() {
    int n;
    cin >> n;
    vector<vector<int>> can(n, vector<int>(5));
    vector<int> cnt(5);
    for(int i = 0; i < n; ++i) {
        for(int j = 0; j < 5; ++j) {
            cin >> can[i][j];
            cnt[j] += can[i][j];
        }
    }
    if(n & 1) {
        cout << "NO\n";
        return;
    }
    const int need = n >> 1;
    for(int a = 0; a < 5; ++a) {
        for(int b = a + 1; b < 5; ++b) {
            if(cnt[a] >= need && cnt[b] >= need) {
                bool ok = true;
                int f = 0, g = 0, h = 0;
                for(int row = 0; row < n; ++row) {
                    if(can[row][a] && !can[row][b])
                        ++f;
                    else if(!can[row][a] && can[row][b])
                        ++g;
                    else if(can[row][a] && can[row][b])
                        ++h;
                    else {
                        ok = false;
                        break;
                    }
                }
                if(!ok)
                    continue;
                int f_need = max(0, need - f);
                int g_need = max(0, need - g);
                h -= f_need;
                h -= g_need;
                if(h >= 0) {
                    cout << "YES\n";
                    return;
                }
            }
        }
    }
    cout << "NO\n";
}

Substract the illegal ways from all the ways.

There are in total $$$\dbinom n 3$$$ ways to choose $$$3$$$ elements among $$$n$$$ of them. Now considering how many of them are illegal, that is, none of the two conditions in the statement is satisfied.

To calculate it, we first define cnta[x] as how many times topic x has occured and cntb[x] as how many times difficulties y has occured.

Then assume that we choose the $$$i$$$ th problem, since no two problems share the same $$$a_i$$$ and $$$b_i$$$, we can assume the second problem we choose shares the same $$$a$$$ with $$$a_i$$$ and the third problem shares the same $$$b$$$ with $$$b_i$$$. So we just need to calculate 1ll * (cnta[a[i]] - 1) * (cntb[b[i] - 1]).

You can view my code 131440598 for more details.

Sorry for my poor English(

Penalties are for the leader board. More time used means lower ranking.

I think the hacks exploit this.

I believe you can have all numbers from $$$1$$$ to $$$100000$$$ and create the pairs $$$(1, 100000)\ (2, 100000)\ \dots\ (100000, 100000)\ (1, 1)\ (1, 2)\ \dots\ (1, 99999)$$$.

In that way there are $$$2\cdot 10^5 - 1$$$ pairs (possible because $$$n\leq2\cdot 10^5$$$) but the product of counts will overflow if they are initialized as int. (for example considering the first pair the counts will both be $$$99999$$$)

Assuming that you are doing a bfs for each query : giving the fact the number of situations is at most (nb of x * nb of y * nb dir = N*M*2), the total complexity of your algorithm is O(N*M*2*Q + N*M) = O(N*M*Q), which is too slow. Sorry for my bad English.

To make your code cleaner, you can use array<ll, 4> instead of those pairs, here is the AC code with that modification 131514905

try this

1
6
1 0 0 1 0
0 0 0 1 0
0 1 0 0 1
0 1 0 1 1
0 1 0 1 1
0 1 0 1 1

just use (long long) instead of (int) here: cout<<int(s)<<'\n'; int has been overflowed, not double

yeah its because of anti hash test case which is causing the unordered map to have a bad hashing