The test on which your code is failing is small in size(n=m=p=10) so you can use it as a counter-testcase and debug..

'a' can never be removed as it has no previous letter (see problem statement)

I think you misunderstood the meaning of this problem. You should read it again carefully.

We can't remove 'a'.it's mentioned in the problem.

Actually i got very confused so according to question b is previous element of a, or y is previous element of z,but a is not previous element of d.I wasted a lot of time in this

For me that just proofs that for the lexicographically last letter (ie 'z') there is no letter after that one. Then it states that if such one is removed, all other possible removals still exist. So we can remove letters in reverse lexicographically order. Kind of induction.

In short, the tuition is like this. Since you have the transformation is to change "011" to "110" and vice versa, the parity of the number of "1" between any two consecutive "0"s remains. Therefore, if there is any "11" in our original string, the fact that you delete it would not change anything. Just delete all "11" in the original string, and you obtain a shorter new string. To answer queries, just pick the substrings of the new string that correspond to the substrings in the original, and compare if they are the same.

For those like me — This problem requires segment tree with lazy update

If you make the transposed graph (basically all edges in opposite direction) and calculate the shortest distance from the last node, you'll see that the given path is indeed the shortest path from 8 to 1. Therefore, if I take this path on node 8, I can continue with this. Question asked rebuilds not builds so first build is excluded.

You have an error in overflowing values. The maximum value for n is 2*10^5, for each number 4*10^5. Multiplying these numbers we get 8*10^10. While int can store data up to 2*10^9. Replace the int with long long. P.S. And in general, I would recommend doing this task the way it is editorial, because on big tests you will get TL.

It is something as follow: We first try to remove occurrences of 'z'. Now if there any 'z' remaining that can't be removed. Then we remove occurrences of 'y' wherever possible. and so on.

And here in each pass you can scan entire array. As there are only about 100 characters.

Now, you may ask why we are not starting with 'a' then 'b' then 'c' and so on...?

Because suppose you have following string — 'cbca'. Then if we had tried to remove 'b' then it would not be remove after it's pass gets over. But after removing 'c' string becomes 'ba'. So, we find out that we can also remove 'b'.

And if you think a little bit than you will see that in our approach of removing characters in reverse alphabetical order once we find that we can't remove given character then we will never be able to remove that character in future.

can you explain it's states?

You need to add a break at line 39.

https://mirror.codeforces.com/contest/1320/submission/79646922

Lol yep, my bfs is wrong.

In my implementation, it's possible that's nodes can be pushed twice in the queue. This should not be the case when counting paths. I got AC after fixing this.

I am already solved. thanks~.

Let's represent all the monsters as the points at the coordinate plane: a monster with $$$x$$$ toughness, $$$y$$$ power, and $$$z$$$ coins is represented by the point $$$(x,y)$$$ with value $$$z$$$. For each pair of a sword with power $$$x_0$$$ and a shield with toughness $$$y_0$$$, the result is the sum of values over the points which belong to the rectangle $$$0 \leqslant x < x_0, 0 \leqslant y < y_0$$$ minus their costs.
Let's now apply the scanline technique: we will process the events of two types: a new monster and a new sword. Let's build a segment tree over the (sorted by toughness) list of shields and define the current set of monsters (initially empty) as $$$S$$$. For each shield with toughness $$$y_0$$$ and cost $$$c$$$, a leaf value in the segment tree stores

Let's sort an array of events by $$$x$$$. If some sword has the same power as some monster's toughness, then the sword is processed before. For each event in the sorted order:
- If it's a monster with power $$$y$$$ and value $$$z$$$, then for each shield with the higher toughness add $$$z$$$, which means adding on some suffix segment of the segment tree. That monster is added to $$$S$$$;
- If it's a sword with power $$$y$$$, then you need to find the shield with the biggest value in the segment tree. The final answer is the biggest value among the values of these pairs.

Same here

i willbuscu anyone helpme