For the first subtask, we can brute force all possible combinations of the array
, and check if they match the constraints.
Time Complexity: 
For the rest of the subtasks (in general), we need to improve the time complexity.
Let us look at the xor
operation first. A bit
in
is set if and only if there is an odd number of
s with the
bit set. A bit
in
is not set if there is an even number of
s with the
bit set. Thus, we need to look at each bit in
individually. If the
bit is set, we need to calculate the number of ways to place an odd number of set bits in the array
of size
. Thus,
(
choose an odd number). If the
bit is not set, we need to calculate the number of ways to place an even number of set bits in the array
of size
. Thus,
(
choose an even number).
For the or
operation, the
bit in
is set if any of
has set bit
. An
bit in
is unset if all of
has an unset bit
. Similar to the xor
operation, we must loop through each bit. There are
ways to choose a combination for the
elements, such that at least one of them has a set bit
, and there is exactly
way to choose a combination for the
elements, such that all bit
s are unset.
The and
operation can be handled in the same manner as the or
operation, and so we will leave it as an exercise for the reader.
With this, we can go through each bit
up to
, and multiply the number of ways for each bit accordingly. Be wary to modulo to prevent overflow.
It is trivial to calculate
with Exponentiation By Squaring. To calculate
and
quickly requires a little more mathematical insight (which are the next 3 subtasks).
For the second subtask, we can precompute by looping up to
(
to
inclusive), and calculate
. Multiply all even
into a final variable, and all odd
into another variable. Note that we need to use modular division in order to prevent overflow. Noticing that
is a prime, we can use Fermat's Little Theorem to calculate the modular multiplicative inverse, and perform modular division accordingly (by multiplying by the modular multiplicative inverse).
Time Complexity: 
For the third subtask, we notice that
is not a prime. Instead of performing modular division in order to compute
, we need an alternative. We can use a segment tree or balanced binary search tree (similar to this problem) that stores the prime factors. When moving from
to
, we need to remove some prime factors, and add some. For more details, refer to the editorial from that problem.
Time Complexity:
or better
For the last subtask,
, meaning that even
is too slow. We need a sublinear algorithm. With some mathematical insight, we can show that
(If you want a formal proof, open a ticket by clicking the "Report an issue" button at the bottom of the problem description). Thus, we can use Exponentiation By Squaring to precompute the values needed for the xor
operation as well.
Time Complexity: 
Comments