so sad that people downvoteing :/

I hope I will be able to do more than 1 problem this time xD

Educational CF Round and Div.3 Round have no points penalty. Instead, they have time penalty, which depends on the time when a participant submitted correct submission and the number of wrong submission. In detail, if you solved problem k minutes after the start of the competition, your solved problem number increases by 1, and your penalty increases by 10×(the number of wrong submission on that problem)+k.

Why are you so eager to become green?

you can't because this contest is only rated for trusted participants. And the criteria being trusted is

1. take part in at least two rated rounds (and solve at least one problem in each of them)
2. do not have a point of 1900 or higher in the rating.

and you didn't participate any contest till now.

you can deregister yourself by going to the registants page and click the red x button :D

nope

Please upvote my contribution lies in -30

i think anyone can't write div3

Div 3 and Educational Rounds don't have score distribution.

They have penalties on time

The hacking phase starts after the contest ends.

Solution for $$$E2$$$:

Firstly observe that the question asks to use minimum number of colors such that subsequence formed by each color is sorted.

Consider the longest decreasing subsequence (LDS) of the given array. Observe that no two elements of this sequence can be given the same color, hence number of colors must be greater than or equal to the length of the LDS.

Now, to find a coloring with number of colors equal to length of LDS, let $$$lds(i)$$$ denote the length of longest decreasing subsequence which ends at $$$i$$$ and includes the $$$i$$$th element. Observe that if $$$a_i > a_j$$$ with $$$i < j$$$, then $$$lds(j) > lds(i)$$$. Importantly, $$$lds(j) \neq lds(i)$$$. Thus, you can just assign the $$$i$$$th element the color $$$lds(i)$$$.

You can also just check that a letter can't be assigned to the same color of any letter that has greater value and appears before (it is an inversion). I assigned bitmasks to every letter and every mask will have a bit of the corresponding color active if there is a letter that was already assigned to that color.

Name collision with data function, which was added in c++17

There's a template function in c++17 names "std::data", which makes your data variable ambiguous

You need 2 tricks for 10 and 50 (10-2-3-2-(?)-2-(?)-2), same mechanism for 50. So you can't have 50 and 10 simultaneously

first , fourth and fifth monster can be killed without secret technique . Last monster can be killed by using technique once and rest of the monsters can be only killed using technique twice .

CodeGreedy

May be you have not registered for the contest...

Maybe you have not registered for the contest... Sorry commented again

You were expert, the time you registered for the contest. So you are out of competiton.

5

2 2 2 2 2

check this case

Using +2 for "UP" and +1 for "RIGHT" means that your program thinks "ULL" is a net-zero sequence of moves. You could do some approach like this, if you did +N for "UP" and +1 for "RIGHT", then there would be no ambiguity because it would be impossible for enough L's to cancel out a U. Or you could just keep track of the sum into two parts, a netVertical and netHorizontal.

1 6 UULLLL

just replace 2 with 10^6 but your code will still be tle, try hashmap, changed solution of yours it passes test case 6 my solution with hashmap with linear time complexity

everyone didn't solved a single problem at the first time... cheer up man practice hard and get ready for the next contest.

@Ernis In the Codeforces Educational Round #81, I am also not able to solve a single problem. But in this contest, I performed decently. So just compete and don't give up.

Try to upsolve problems after contest has over ..its better for U

may be the run time error because s.length type is unsigned integer so when the length is 0

1 — length equal to unsigned integer max not -1

Print s.length()-3 and check the value then your questiom will be "how it passed 1st 5 cases?"

Sort the query asked by passenger in increasing order of minimum distance in path.

now let for query(a,b,g) if i already assigned all edges with cost less g and assign all edge in path from a to b with g(if any edge is already assigned with less cost then reassign it with g) then minimum cost for a path can't be less than g. Since i am assigning the cost in increasing order then it might be the case that minimum cost in path from a to b can be greater than g(let after reassigning all edge with cost>g). So assign cost to all edges that come in path for every query in increasing order of cost and after processing all query check the minimum cost for every path in query if it doesn't match then there is no valid answer. if every query matches then we have the answer.

here is my submission

I solved it in O(n^2) but i am curious to know any soln with less complexity.

For C

Store the current location while iterating you can begin at (0, 0) increase the values accordingly for L, U, R and D

Store the last seen locations in a map or set and when you reach a point you've seen before check if the distance between the current index and index of where you last met the point is minimum and save it as your result.

For D

Calculate the number of tricks (the secret technique) you will need to gain points from each monster ignore if 0 (add 1 point to the result since you already earned it) sort the other trick values and pick from the minimum while k is sufficient

You will need a trick if h mod (a + b) = 0, you need exactly ceil(b / a) tricks for that

Or if h mod (a + b) > a let's call the remainder rem you need exactly ceil(rem — a / a) tricks for that.

Interesting, if someone could throw a light it'd be great.

so D is easier? :D

but I felt D was slightly difficult

I was doing TLE hacks. In the end I was able to hack more than $$$100$$$ submissions with the same hack. My test was just to construct a tree in the form of a line, then do queries from one end to the other with weight $$$10^6$$$. To make the queries a bit heavier I made all the labels random and never asked the same query twice.

One fun thing to note was that my test case hacked the checker for the problem.

I've seen my hack take $$$46$$$ ms submissions to $$$1.3$$$ s, so my test was far heavier than the original test cases. Honestly the reason why my hack was so effective was because the original $$$267$$$ test cases were really sub-par. Not only did they not test the obvious max case, there were also obvious patterns in the data. For example if you made node $$$1$$$ be the root, then parent[i] < i in every single one of the original $$$267$$$ test cases. dorijanlendvaj noticed this pattern after I showed him a $$$46$$$ ms submission that I had made TLE. He figured out that the code got stuck in an infinite loop if parent[i] > i, which never happened in the original test cases.

Proof

It happens often if your solution runs closer to the TL. Runtimes can vary quite a lot (maybe up to 200 ms), but usually 30-60 ms.

Just so you know, you could have just done c[x,y] instead of c[str(x) + "," + str(y)]

The cycles can be not only of length 2 and 4.

1
8
LLUURRDD

Correct answer is 1 8.