In F why does dp with bitmask fail? For each edge, I had a mask that represented that if, I painted this edge black then which constraints will be satisfied due to it.

Now just a dp(edgeNumber, mask).

For E LCM can be calculated with idea product of two numbers=gcd * lcm. for large number we can take modulus

Can anyone share the implementation of E.I am not able to implement E.

why it is -1^r in problem can you plz clear it saketh

In F , I have done Meet in the middle and then SOS-DP (https://atcoder.jp/contests/abc152/submissions/13014638)

Thats beacuse of overflow while calculating lcm(a1,a2,...,an).

the idea is to factorize the numbers, you can come up with a formula for finding LCM(a_1, a_2, ..., a_n) from their prime representations.

Python can solve this trivially. Code

Define f(a,b) as number of integers less than or equal to n such that the first digit is a and the last digit is b. Observe that the solution is f(a,b)*f(b,a) over all possibilities. there are 81 possibilities (as leading 0's are not allowed) like so)

why no code in D, E, and F?

Yes,After the contest go to Results tab then All Submissions.

First, fix an integer $$$A$$$ where $$$1 \leq A \leq N$$$. Assume that the first digit of $$$A$$$ is $$$i$$$ and the last digit is $$$j$$$. How many $$$B$$$s are there that satisfies the given condition? The necessary and sufficient condition is that the first digit of $$$B$$$ is $$$j$$$ and the last digit is $$$i$$$. So, in order to count them, you can iterate the integers from $$$1$$$ to $$$N$$$, and check whether each of them satisfies the conditions written above or not.

Then what to do next? Since $$$N$$$ can be up to $$$2 \times 10^5$$$, the total loops can be up to $$$4 \times 10^10$$$, so it won't finish in time. This means that you are wasting time for something, typically doing the same calculation over and over again. Now focus on this step mentioned above:

you can iterate the integers from $$$1$$$ to $$$N$$$, and check whether each of them satisfies the conditions written above (= whether its first digit is $$$j$$$ and the last digit is $$$i$$$) or not

Instead of performing the step for every $$$A$$$, you can count "the number of integers such that the first digit is $$$j$$$ and the last digit is $$$i$$$" (Let this number be $$$c_{ji}$$$ by looping through from $$$1$$$ to $$$N$$$ only once. So, you could solve this problem.

m<=min(20,n*(n-1)/2)

so if n==50, m could be as large as 50*(50-1)/2=1225. It's hard to imagine that n*m*2^m could be under TL...

but since you got AC, the m in testcases should be much smaller than the problem stated.

Actually it could be O(n*m+2^m).

First, precompute all edges for each constraint and save as bitmask. (n<=50, so it's doable). This part is O(n*m).

Then enumerate constraint combinations. Through the way just do bitmask or operation. With each combinations mask, __builtin_popcountll(...) could be used to figure out how much 1s in the long long mask, which let me get rid of O(n) loop, and it's said to be O(1). This part is O(2^m) in total.

My submission if you interested

O_E what u didn't get in editorial?i don't think it can be solved for large constraints

I believe you had misunderstood the condition part, for any integer j(1<=j<=i), Pi<=Pj. Any integer here means that all the integers j in the range[1,i] that satisfy the condition, you should edit code as below, but it actually runs TLE:

int total = 0;
for(int i=0; i<n; i++){
    int count = 1;
    for(int j=0; j<=i; j++){
        if(arr[j]<arr[i]){
            count = 0; //violates the condition
            break;
        }
    }
    total += count;
}

You should solve it using min as the editorial shows. Notice that if the all the previous elements Pj>=Pi, Pi is the minimum value for the array from position 1 to position i. We just check how many i s satisfy this condition.