you practice so hard and participate almost every contest in codeforces!

It's probably the other way around

It's temporary and there is a very good reason for it (https://mirror.codeforces.com/blog/entry/126654).

lol

No, 10 minutes penalty for each wrong submission.

So, in first turn we move to (1,2) and than we have to move like an arrow on this cell, so this turn we end in cell (1,3). In second turn we move to (2,3) and again we have to move like an arrow, so from (2,3) we move to (2,4).

I also tried DP, mine also failed on 787th test case in div2 c.. My submission:

Can someone pls help 251548692

Here's my memoized dp solution for C with simple observation that diagonal elements must be '>' 251558857

[Deleted]

orz

I wrote BFS for C and it's easy.

checkout my solution (observation)

wow that's great!!

bros well rested and on crack too

If any index $$$i$$$ is part of the latter half of a tandem repeat of length $$$2j$$$, then $$$a_i = a_{i - j}$$$ (considering '?' as equal to anything) must hold, lets say $$$good_{i, j} = 1$$$ if this is satisfied for a given $$$(i, j)$$$ and $$$0$$$ otherwise. We can clearly calculate these values of $$$good_{i, j}$$$ in $$$O(n^2)$$$ time.

Then any index $$$i$$$ to be the start of the second half of a tandem repeat of length $$$2j$$$, $$$good_{k, j} = 1$$$ must hold for all $$$i \leq k \leq i + j - 1$$$. This can be checked in $$$O(1)$$$ by storing prefix sums of $$$good_{i, j}$$$ or in a total of $$$O(n)$$$ over all $$$i$$$ by just iterating in decreasing order of $$$i$$$ and keeping track of the most recent pos $$$p$$$ where $$$good_{p, j} = 0$$$.

So for each $$$1 \leq j \leq \lfloor \frac{n}{2} \rfloor$$$, we just iterate on $$$i$$$ in decreasing order and check all possible tandem repeats in $$$O(n^2)$$$ time.

Code — 251486634 ($$$i$$$ and $$$j$$$ are swapped compared to my notation here)

I did $$$n^2$$$ DP, where $$$dp[i][j]$$$ is the maximum length of repeat string we can get if the first half of the string starts from $$$i$$$ and the second half of the string starts from $$$j$$$

I think tourist's solution for problem D is simple and easy to understand. He did it in under a frickin minute.

Linear search on answer.

1. Always break the first number (except if its digits are in desc order), as its a no-brainer.
2. Try if the next number in array can be broken and sorting order is maintained. If yes, keep going otherwise you can't break.
3. At end check if new array is sorted or not.

I have a feeling it is not, as it depends on 3 parameters, although I might be wrong

It is easily googleable https://math.stackexchange.com/questions/562119/difference-of-two-binomial-random-variables

Yeah, it's a bit strange, since we could solve it in O(n). At first I thought it is some kind of DP problem after seeing the constraints.

Is the checker algorithm runs in $$$O(N^3)$$$? Lol I dunno

Actually I think BFS or DFS is the most straightforward solution to it

void solve() {

ll n;
cin >> n;
string s1, s2;
cin >> s1 >> s2;
if (s2[n - 2] != '>') {
    cout << no << endl;
    return;
}
ll tem1 = -1;
bool x = false;
for (int i = 0; i < n; i += 2) {
    if (s1[i] == '<') {
        x=true;
        break;
    }
}
if (!x) {
    cout << yes << endl;
    return;
}
for (int i = 1; i < n; i += 2) {
    if (s1[i] == '>') {
        tem1 = i;
    }
    else {
        break;
    }
}
for (int i = tem1 + 1; i < n; i += 2) {
    if (s2[i] != '>') {
        cout << no << endl;
        return;
    }
}
cout << yes << endl;

}

It's not, only DS or algorithm you need is prefix sum or segment tree

If you think the problems are really good, you can vote against me because it really saves time for all of us.

Yes me

initialize dp[0][0] as 1. if there is a '>' you can go to the next coloumn from left or up or down.

dp[0][0]=1;
    for(int i=0;i<n;i++){
        if(str[0][i]=='>'){
            dp[0][i+1] |= dp[1][i];
            if(i) dp[0][i+1] |= dp[0][i-1];
        }
        if(str[1][i]=='>'){
            dp[1][i+1] |= dp[0][i];
            if(i) dp[1][i+1] |= dp[1][i-1];
        }
    }
    if(dp[1][n-1])
        yes
    else
        no

Can u explain the logic

what's the logic behind that ?

not really imo

It's not that similar but while solving I remembered that problem.

No ,I think there is a brute force type solution of O(n^2) that is working or as told by Pirate_King below the pretest cases were weak allowing O(n^3) fully brute forced solutions

Now for O(n^2) solution :-

SEE THE SOLUTION LINK BELOW YOU WILL UNDERSTAND EASILY

here we are brute forcing or looping for half length of tandem repeat hence we will make loop from i=1 to i=n/2 then for each length i of tandem repeat we will check with another loop from j=0 to i+j<n whether that length tandem repeat is present in string or not

By checking whether current_index and current_index+currlength of tandem repeat we are searching are equal or not if equal then we will take count of consecutive index which is satisfying this condition if this count becomes equal to currenttandemsearchlength then the current answer becomes equal to currenttandemsearchlength now will calculate this answer for every length iteration and at last will print the answer(which automatically stores max length)

254855666

Look at the hacks bro. The testcases were weak so $$$O(n^3)$$$ solutions passed. Solve count gonna drop significantly after system testing

Why do you ask?

Yes was confused between that robot have to reach last block(2,n) after performing both the operations OR robot have to just touch the last block

P.S. robot have to reach last block after performing both the actions is correct way for C

Actions

There is a robot that starts in a cell (1,1). Every second, the following two actions happen one after another:

Firstly, the robot moves left, right, down or up (it can't try to go outside the grid, and can't skip a move); then it moves along the arrow that is placed in the current cell (the cell it ends up after its move). Your task is to determine whether the robot can reach the cell (2,n)

Interesting -- apparently this is caused by a bug in the compiler. I also could reproduce the error with custom tests. Meanwhile I could avoid the error by moving the definition of vis to global (and initialize them appropriately).

By C++ standard you can't declare an array of variable length. The size of it must be constant expression (known during compilation). However, there are compiler extensions that allow them, but anyways compiler is not obligated to have them. It seems that this particular version doesn't. Or it doesn't support boolean arrays of variable length explicitly. In any case this can't be considered a bug.

It seems to me that it has to do with the ordering of the dimensions in terms of constants. Simply changing the definition from $$$vis[2][n]$$$ to $$$vis[n][2]$$$ resolved the issue

You declared this array char a[2][maxn];

Then below, you accessed at a[2][j - 1] (a[2] is out of range, so it will cause an undefined behavior)

Optimistically thinking, you are the first 18 people to solve this problem. It's enough to show that your programming level is really very high (maybe)

Also their solutions for B are extremely similar. In fact, both laxmiprasanna_ and sudhanshu_24 have the same code verbatim: -251532572 -251536131.

Or it's just a coincidence haha.

5
77 0 79 42 69

Presented arrangment of values really allows to relate 4th index for both cliques, but we don't need it to be in both cliques the same time (since we need splitting, not coverage of graph)

So we choose to relate it to first clique and leave second clique without it (which doesn't prevent the remnants of the second clique from still being a clique)

There are 40*80 distinct testcases, and there are 5 test files (1 sample and 4 hidden).
I believe system tests do cover all the distinct testcases.
The only hack possible should be TLEs by repeating the same test if someone is doing some bruteforces.

1
3
1 23 21

Expected answer is YES.

It is not in both cliques. You define cliques by the array c. c[3] has exactly one value, thus it is in exactly one clique. The constraint is that the nodes you mark with the same id really form a clique, not that those are all the cliques in the graph.