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 wrote BFS for C and it's easy.

checkout my solution (observation)

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.

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.

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

not really imo

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

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)