Tutorial is loading...

Writer: PrinceOfPersia

Tutorial is loading...

Writer: PrinceOfPersia

Tutorial is loading...

Writer: PrinceOfPersia

Tutorial is loading...

Writer: PrinceOfPersia

Tutorial is loading...

Writer: PrinceOfPersia

Tutorial is loading...

Writer: Reyna

Tutorial is loading...

Writer: PrinceOfPersia

Bonus question for Div1B: try to solve when sigma can be of size of m.

Could you please explain how to solve this (bonus) problem? I've no idea...

Probably something like

DP[u][v] is the maximum character needed for a person to be on u (on his turn), the other on v and the first wins no matter what.

Yes ,you are right.I misunderstood it.

Expected Complexity:O(n*n*n)

SpoilerMy idea is to maintain a dp state having [1st player position],[2nd player position],[edge number in adjacency list of 1st player from which he can take an edge].

(Here assuming adjacency lists are sorted by symbols on edge).

Now

dp[i][j][k]=dp[i][j][k+1]

dp[i][j][k]=max(dp[i][j][k],dp[j][x][y]).

where x is kth element in adjacency list of i and y is the lowest position in adjacency list of j which contains a symbol greater than or equal to that present on edge i to x(which can be found using binary search) or do a two pointers.

Complexity:O(n*n*n)

Accepted code

O(n^3 * logn)? The solution I described is O(n * (n + m)). Here's a submission of that solution: http://codeforces.com/contest/917/submission/34697087

Ohh I am sorry.I was thinking something different.Yes you are right!!!

How is this O(n(n+m)) ?

Every (u, v) edge will be considered in state [u][i] for any i, so the transition is O(n*m) and there are O(n*n) states.

There are n*n states and each transition is n*m so isnt the complexity O(n*n*(n+m)) instead of O(n*(n+m))

No, because if you consider each edge, it will be considered only on the states that the first state is the vertex it starts. So each edge is considered for n states (the first state is fixed but the second can be any of the n).

Congrats, you just caused this problem to become of positive value :P

I have a (maybe simpler and elegant?) solution for div1 A.

How would you solve this if no question marks were involved? Well, this is a standard problem. You iterate through the possible substrings and keep a

`score`

which starts from 0, which represents how many open brackets we have. Whenever you iterate over a '(', you add 1 and when you iterate over ')', you subtract one. The string is valid iff at the end the score is 0 and at no point during the iteration was the score negative.For the problem at hand, we do the exact same thing, except we keep one more counter, say

`qmarks`

, which represents the number of question marks so far. Obviously, when we iterate over '?'. we increment this counter. Also, if at any point of the iteration we have`qmarks > score`

, then at least one of the question marks has to be an open bracket (if they were all closed brackets, we would have negative score, which is illegal). Therefore, if this situation occurs, increment`score`

and decrement`qmarks`

.At the end, a substring is legal iff its length is even and

`qmarks >= score`

(we can use question marks to close off all remaining open brackets).Seems simpler than the solution in the editorial (and also doesn't use additional memory, if that's relevant).

simple solution, thank u so much...u saved me from official solution

Nice One :) .

Thanks for such a nice solution.

I had basically the same solution but (again maybe?) just a little more natural to explain.

At each moment we will define

landras minimum and maximum number of unclosed brackets in the sequence before given that it is a prefix of a correct bracket sequence. For every starting position initiallyl=r= 0. When we iterate over '(' or ')' we obviously increase or decrease both by one correspondingly. When we iterate over '?' we decreaseland increaserby one. Ifr< 0 at any point we stop here and go to a next starting position.lcan't be less than 0, so ifl< 0 we increase it by 2. Finally the ending position is possible if and only ifl= 0.CodeCould you please explain it on a test: "???(" ?. Here, if I consider the whole substring, right from the 1st iteration, qmarks > score. so: qmarks = 1 score = -1; qmarks = 2; score = -2; qmarks = 3; score = -3; score = -2

Hence, the length is even and qmarks >= score. Hence it's legal. But you can't form any valid bracket with this sequence. Am i missing something?

When qmarks > score, you decrement qmarks and increase score, not the other way around. The logic is that you turn a question mark into an open bracket, since at least one of the question marks has to be open.

Thank you so much. I don't understand why editorialists don't write editorials like this.

Proof is important too.

Won't the time complexity be O(n^3) then?O(n^2) for every every substring and checking takes another O(n).?

Actually, you don't need to check

`qmarks>=score`

, just`qmarks==score`

would do, as you're deliberately balancing`qmarks`

and`score`

is`qmarks>score`

.Here is a submission describing that.

Solution #2 for problem D is just beautiful!

And India is blessed to have a coder like you.

Div 1 E : "First two variables can be calculated using aho-corasick and segment tree." Can someone explain how to do this? Thanks in advance.

How can i solve div2 C with dp?

I hope someone can answer my confusion...To Div2 D,I still can't understand the rightness of the editorial.Can this ensure that both players play optimally?

if one's make "a" move can make other lose then it is optimally move right? so you have to find a path that the ichar(i) is big enough that the next person cant go any further

c < int(ch(v, x) - 'a') and dp(u, x, ch(v, x)) = false its mean the ichar you have is larger than the limit now and the ichar you have ,can make the next player fail to move,( dp is false) , thus the state now is true

Thanks a lot!

I steal couldn't understand the problem solution :(

maybe you shoulde study classical sg function first

what is " sg function " ?

Sprague-Grundy theorem you can google it

How Sprague-Grundy theorem can be used here?? can you explain?? It seems that only DP is used here.

I made a mistake...sorry..

Could anyone please tell me what is sigma in 917B editorial?

Sigma is the size of the constraint on the edge. In this case,its 26. If we allowed numbers(from 0 to 9) and alphabets both in the problem, then it would have been 36.

Can someone please explain more precise how to make the the dp with matrix multiplication on Div1C/Div2E? Especially how to construct the matrix to be multiplicated and the initial step of the dp? I have tried to mulptiply the matrix

`m[i][j]`

as cost to go from state number i to state number j, but I couldn't find the recurrenceSame. I am also really confused about this part.

In E do you even build suffix trees for every

s_{i}andt_{i}(or just one big suffix tree)? And if you do, how to get position in small tree from position in big tree?In my submission (343647) I only build two big suffix trees explicitly.

In the centroid decomposition I find for each query one node in each of these 'big trees'. After the centroid decomposition I preprocess one of the suffix trees, finding for each of the queries the last node in the suffix tree that is an ancestor of the node from the centroid decomposition and is a suffix of the special word for the query (which is probably what you call 'the position in the small tree', see wlast, oldwlast and qstidx in my code).

Also at the same time I construct for each suffix of a special word the range in the inorder traversal for that special word that corresponds to the subtree (which is similar to an euler tour of the 'small trees', see bwlid and bwrid in my code).

I think problem E can be solve in O(n^2/32)

Could you explain your solution?

Div1 Problem D dp[u][us][ue] × dp[v][vs][ve] × N × us why N is in this expression? and what N is?

In DIV1.B shouldn't the editorial have c <= int(ch(v, x) - 'a') ? As it was given should be greatern than or equal ...

namelessgugugu has a $$$O(n^2)$$$ solution to div1D orz

upd: Oh maybe there are lots of them. ignore this