Well... :p

• CodeCraft-22
• CodeCraft-21
• CodeCraft-20
• CodeCraft-19
• CodeCraft-18
• CodeCraft-17

good

It will have a score distribution. We will publish it soon.

fangahawk akcube orz!

What if you become master?

what if you become IM ?

He is an algorithm book and resource by himself.

I can speedrun minecraft, does that mean that I will AK the contest?

me first

Lessgooo!

Yeah I hear a lot about IIIT too....but then everything can't be helped I guess....at this point you should be contributing to building the culture there.

it's annual hackathon by IITH codecraft-24 will by 2025 ig

what meant by score distribution

Only if you knew math, 2021 would have come by now

it is clear from the question that we need for each y

ax ^ ax+1 ^ ax+2 ... ^ ... ^ az-1 ^ az > ax ^ ax+1 ^ ax+2 ... ay ^ ... ^ az-1 ^ az.

note in lhs, ay is missing so basically what we need is all those ranges(x, y) in which sum of MSB of ay is even.

we need x, y, z. traverse through y, now for each y calculate no. good x and z pairs.

suffix and prefix dps can be maintained for each bit for odd and even counts.

I was able to find a recurrence for C but was not able to submit in time because of runtime errors.

F(n) = F(n-1) + (2*n-2)*F(n-2)

where n is the total number of row and column numbers which were not used. Not sure if it is correct.

I think the problem is that operation order doesn't matter, so it should be divided by $$$(n/2)!$$$

The 720 possibilities are overcounted. Eg. These two configs are same;

- W(1,3), B(3,1), W(2,4), B(4,2)
- W(2,4), B(4,2), W(1,3), B(3,1)

The final rook positions are same in above 2 cases.

I just solved it once the contest was over:(((((((((((( Unfortunately I couldn't submit my solution which I am sure that it is correct :((

#include <bits/stdc++.h>
using namespace std;

#define ull unsigned long long
#define ll long long
#define ld long double
#define int ll

#define endl '\n'
#define EPS .0000001
#define MOD 1000000007

void calculate();

int dp[300010];
signed main() {
    dp[0] = 1;
    dp[1] = 1;
    for(int i = 2; i <= 300000; i++) {
        dp[i] = dp[i-2]*(i-1)*2+dp[i-1];
        dp[i] %= MOD;
    }
    int t = 1;
    cin >> t;
    for(int i = 1; i <= t; i++) {
        calculate();
    }
}

void calculate() {
    int n, k;
    cin >> n >> k;
    int x, y;
    set<int> st;
    while(k--) {
        cin >> x >> y;
        st.insert(x);
        st.insert(y);
    }
    n -= st.size();
    cout << dp[n] << endl;
}

My way of thinking was similar. There are $$$10$$$ ways for the second rook, because $$$30-(4*8-4*3)=10$$$. And because by filling up the remaining diagonals, all these could be considered as final positions. So after placeing 2 rooks, there are $$$30*10=300$$$ possible positions, which again could be considered as final ones. And then $$$1+30+300$$$ gives $$$331$$$ (the $$$1$$$ is needed because the initial position can also be considered as a final one). But what I don't get is that we overcount the positions after 2 rooks, so it should be $$$150+30+1=181$$$. Can anyone please explain it to me?

Btw, my A got WA on system testing, wow... $$$a_i \le 100$$$ got me there... Definitely, not a good day for me...

this solution would have been correct if two rooks position swapped yields a different setting. but according to problem, they are same. and if you notice carefully, its 6! = 720 and there is a reason for that.

you can look at my solution i did not do recurrence i used combinatorics only.

solve dp I think

basically you can just check whats the biggest number for Math.pow(2,x)-1 <= k because Math.pow(2,x)-1 is only 1's, the rest of the number doesnt really matter and you can sum it up with the difference and the rest 0's

a ^ b < a implies that msb of b should be present in a 
which means for given A[i] ans = no. of pairs l, r such that msb of 
A[i] should be present in that xor(l...r).
i couldn't implement in time but i'm sure it's correct 

UPD :- i was correct 257663607

Let $$$b$$$ be highest bit in k. Then you can get $$$b-1$$$ bitcount by just printing $$$s = 2^{b} - 1$$$. Then print out $$$k - s$$$ and fill the rest with zeros.
Why does this work?
Either $$$k - s$$$ will be greater equal than $$$2^b$$$, then you've got all bits in answer and you can't make it bigger (note that it means k has no 0s in its binary representation,
or $$$k - s$$$ will be smaller, but that means that you "spent" 1 from b-th position to cover up all 0s in lowest bits.