### 670A - Holidays

There are many ways to solve this problem. Let's talk about one of them. At first we need to write a function, which takes the start day of the year and calculate the number of days off in such year. To make it let's iterate on the days of the year and will check every day — is it day off or no. It is easy to show that if the first day of the year equals to the first day of the week (i.e. this day is Monday) in this year will be minimum possible number of the days off. If the first day of the year equals to the first day off of the week (i.e. this day is Saturday) in this year will be maximum possible number of the days off.

### 670B - Game of Robots

To solve this problem we need to brute how many identifiers will called robots in the order from left to right. Let's solve this problem in one indexing. Let the current robot will call *i* identifiers. If *k* - *i* > 0 let's make *k* = *k* - *i* and go to the next robot. Else we need to print *a*[*k*], where *a* is the array with robots identifiers and end our algorithm.

### 670C - Cinema

We need to use *map*-ом (let's call it *cnt*) and calculate how many scientists knows every language (i. e. *cnt*[*i*] equals to the number of scientists who know the language number *i*). Let's use the pair *res*, where we will store the number of \textit{very pleased} scientists and the number of \textit{almost satisfied} scientists. At first let *res* = *make*_*pair*(0, 0). Now we need to iterate through all movies beginning from the first. Let the current movie has the number *i*. Then if *res* < *make*_*pair*(*cnt*[*b*[*i*]], *cnt*[*a*[*i*]]) let's make *res* = *make*_*pair*(*cnt*[*b*[*i*]], *cnt*[*c*[*i*]]) and update the answer with the number of current movie.

### 670D1 - Magic Powder - 1

This problem with small constraints can be solved in the following way. Let's bake cookies one by one until it is possible. For every new cookie let's calculate *val* — how many grams of the magic powder we need to bake it. For this let's brute all ingredients and for the ingredient number *i* if *a*[*i*] ≤ *b*[*i*] let's make *b*[*i*] = *b*[*i*] - *a*[*i*], else let's make *b*[*i*] = 0 and *val* = *val* + *a*[*i*] - *b*[*i*]. When we bruted all ingredients if *val* > *k* than we can't bake more cookies. Else let's make *k* = *k* - *val* and go to bake new cookie.

### 670D2 - Magic Powder - 2

Here we will use binary search on the answer. Let's we check the current answer equals to *cur*. Then the objective function must be realized in the following way. Let's store in the variable *cnt* how many grams of the magic powder we need to bake *cur* cookies. Let's iterate through the ingredients and the current ingredient has the number *i*. Then if *a*[*i*]·*cur* > *b*[*i*] let's make *cnt* = *cnt* + *a*[*i*]·*cur* - *b*[*i*]. If after looking on some ingredient *cnt* becomes more than *k* the objective function must return *false*. If there is no such an ingredient the objective function must return *true*.

If the objective function returned *true* we need to move the left end of the binary search to the *cur*, else we need to move the right end of the binary search to the *cur*.

### 670E - Correct Bracket Sequence Editor

Let's solve this problem in the following way. At first with help of stack let's calculate the array *pos*, where *pos*[*i*] equals to the position of the bracket which paired for the bracket in the position *i*. Then we need to use two arrays *left* and *right*. Then *left*[*i*] will equals to the position of the closest to the left bracket which did not delete and *right*[*i*] will equals to the position of the closest to the right bracket which did not delete. If there are no such brackets we will store -1 in the appropriate position of the array.

Let's the current position of the cursor equals to *p*. Then if the current operation equals to \texttt{L} let's make *p* = *left*[*p*] and if the current operation equals to \texttt{R} let's make *p* = *right*[*p*]. We need now only to think how process the operation \texttt{D}.

Let *lf* equals to *p* and *rg* equals to *pos*[*p*]. If *lf* > *rg* let's swap them. Now we know the ends of the substring which we need to delete now. If *right*[*rg*] = = - 1 we need to move *p* to the left (*p* = *left*[*lf*]), else we need to move *p* to the right (*p* = *right*[*rg*]). Now we need to recalculate the links for the ends of the deleted substring. Here we need to check is there any brackets which we did not deleted to the left and to the right from the ends of the deleted substring.

To print the answer we need to find the position of the first bracket which we did not delete and go through all brackets which we did not delete (with help of the array *right*) and print all such brackets. To find the position of the first bracket which we did not delete we can store in the array all pairs of the ends of substrings which we deleted, then sort this array and find the needed position. Bonus: how we can find this position in the linear time?

### 670F - Restore a Number

At first let's find the length of the Vasya's number. For make this let's brute it. Let the current length equals to *len*. Then if *len* equals to the difference between the length of the given string and the number of digits in *len* if means that *len* is a length of the Vasya's number.

Then we need to remove from the given string all digits which appeared in the number *len*, generate three strings from the remaining digits and choose smaller string from them — this string will be the answer. Let *t* is a substring which Vasya remembered. Which three strings do we need to generate?

Let's write the string

*t*and after that let's write all remaining digits from the given string in the ascending order. This string can be build only if the string*t*does not begin with the digit 0.Let's write at first the smallest digit from the remaining digits which does not equal to 0. If we have no such a digit we can't build such string. Else we need then to write all digits with smaller than the first digit in the

*t*in the ascending order, then write the string*t*and then write all remaining digits in the ascending order.Let's write at first the smallest digit from the remaining digits which does not equal to 0. If we have no such a digit we can't build such string. Else we need then to write all digits with smaller than or equal to the first digit in the

*t*in the ascending order, then write the string*t*and then write all remaining digits in the ascending order.

Also we need to separately consider the case when the Vasya's number equals to zero.

well, that was quick :v

(Sorry for my poor english...) This round was very interesting for me... Thanks a lot fcspartakm ...

In problem C

TLE when using an unorderd map :17741658

Accepted when using a map :17749162

why ?!

In worst case, unordered map works in O(N) time, when ordered has O(logN).

Java solutions work normally using HashMap. Tests should have been more strict to time out all solutions that use hashing, not just C++.

Also unordered_map can pass if you set size to 10000000 / 3. I got this off stackoverflow, and it passed in 600ms which is faster than map.

what do you mean by "set size to 10000000 / 3" ?

When you initialise your map put that number between the brackets. I think it has something to do with load factor or size. I haven't had the time to google/search yet like the guy below me is saying,especially that C++ is not my main language. Have a look at my latest submission if you need an example, I'm on mobile and can't link.

Hello,

in C++ you can use for example "M.max_load_factor(.4)"

You should try to understand how std::unordered_map is implemented rather than just "hack" around it.

Same problem :( I won't use unordered containers in C++ anymore!

i don't know how c++ implements the map . but in java Hash Map worst case is O(n) but it rarely happens .. the common is o(1) but if we assume that the probability of collision is big the worst case would be O(n/K) k is a constant number . but in Tree map or ordered map in c++ . it guarantees O(log n ) for basic operation .

Hi guys I used binary search to solve problem B. Simple and easy.

17739820

Easy solved problem?

by easy I mean easy concept. the WA's occured cause of using int when i changed that to ll it worked.

You can just solve this quadratic equation to get the right x. I would say this is a lot easier then binary search.

yes you could do that but for some reason my brain did not work in the contest.

Can anybody help me with my solution for problem E. Expected output and my output are same. But still, I am getting a wrong answer. 17746092

This is because of printing '\n' in your solution.

it is because of out of array index. I changed your while to :

`while(st!=(n))`

http://codeforces.com/contest/670/submission/17764901

I'm Pretty Sure I've solved E correctly with a good complexity using linked list

However the system gives me TLE on pretest 1 even though it works on ideone.17748382

could someone please help me out on this it's driving me crazy thx

ah well :-(

You could use custom invocation to test on codeforces.

That's the problem. It gives me TLE even on custom invocation (which means it takes at least 10 seconds) even though it works perfectly on ideone: http://ideone.com/cIPfDR

You should replace s.erase(it); by it=s.erase(it); otherwise it is not clear where "it" is pointing out once you remove the element from the list.

This will let you pass the first pretests but then you will hit test 8. The problem there is different, you have trouble at the 4 instruction that corresponds to the second delete instrucition. When you remove a group of parenthesis at the end of the list, the new position should be the previous position not the next one.

Thank you very much!!!!

could someone tell me why my code for E gets TLE on test case 77?

That's when the number of queries is very big. But doesn't my code spend per query? Is there some case that makes it

O(n)?The basic idea is to just build a segment tree on top of the input, where a node is either alive or dead and corresponds to a subset of parenthesis of size 2

^{i}. To remove all nodes betweenlandrall you need to do is kill the nodes that correspond to intervals [l',r'] that are contained within the interval [l,r]. Going right/left corresponds to finding the alive successor/predecessor leaf of the leaf that your cursor is currently positioned at. This should also be doable in time.There is simple

`O(n)`

solution. ST doesn't necessary. Keep it short and simpleI am aware of the O(n) solution, I just need to understand why my solution with segment trees does not work.

And use scanf / printf

unfortunately it doesn't change much

problem D was awesome :D

similar to 371C - Hamburgers

exactly :D Binary search problems are always wonderful

**IN PROBLEM B **

There is a solution in O(1) http://codeforces.com/contest/670/submission/17761850

How can there be a O(1) solution,if you read the array in O(n)? Before posting something stupid,check your affirmation!!

Chill out, his solution is still useful, and gives you new options to attack the problem.

He probably meant O(1) without counting the reading part so just tell him nicely, we are a "community" after all...

I mean O(1) except getting the elements of the array ! thank you

Unfortunately, your solution has

O(n)complexity because of reading n elements.I mean O(1) except getting the elements of the array ! thank you

why am getting Wa on problem F? is my solution is wrong? http://codeforces.com/contest/670/submission/17762248 if it does can you explain me why?

Your solution fails on this:

The answer is 1013.

Though, mine passes test 4 but fails on this test too, so I'm not sure if it's exactly what you're looking for.

My code for problem F gives runtime error on test case 7.Code Does anyone know why?

I would highly appreciate if someone could explain the solution to problem B in more details.

Here is my solution which got TLE. I basically checked for all the ids called by a particular robot. I mentioned my naive solution so that a comparison with the expected solution can be drawn. Thanks in advance. :)

Problem D2. Not able to find any error in my solution. It fails in test case 128. Can someone please help in finding out the error. I uploaded the same code for D1 which got accepted. Here is my solution. Please help :p http://codeforces.com/contest/670/submission/17734861

It is probably overflow. I had the same problem. Try changing the high value to 2e9.

I'll look into it again. But I am calculating what the highest value could be.(variable 'ma' in the code).

it seems that "req" exceeds long long code

thank you :)

Can someone tell me what is wrong with my approach 17778797 to solve

E? It got Wrong Answer.My approach:

`pr[i]=j`

indicatesith bracket matches withjth bracket. I have used four stacks (`left_part`

to store left part of the string,`Left`

to store the positions of the brackets of`left_part`

, similarly`right_part`

and`Right`

), though it can be done more effortlessly.`next_right`

and`next_left`

which respectively stores the position of the closest undeleted bracket at the right and the position of the closest undeleted bracket at the left.`border`

to mark the end of the valid string. It is equal to the position of the rightmost undeleted bracket plus 1.a. if the current operation is "R",

`p=next_right[p]`

b. else if the current operation is "L",

`p=next_left[p]`

c. else if the current operation is "D" :

`l=p, r=pr[p], if l>r : swap(l,r)`

`if r+1==border : p=l-1, border=l`

`else : p=r+1, next_right[l-1]=r+1, next_left[r+1]=l-1`

`fill [l,r] of the string with '*'`

, meaning these locations are deleted (Ihave done this to avoid re-calculation of

`pr`

)5. Print the characters of the initial string of brackets if the character is not '*'.

It should be

`next_right[l-1]=next[r]`

and`next_left[r]=next_left[l]`

because in a certain moment

`r+1`

doesn't represent the next position of`r`

after some deletions.Thanks for your reply. Actually, your suggestion has some bugs, but the reason you have given is perfectly correct!

I have found out what was wrong with the solution, thanks to you! Basically, inside the deletion

operation, all

`r+1`

(except the border checking) should be replaced by`next_right[r]`

and all`l-1`

should be replaced by`next_left[l]`

(I had considered this case only in 'L' and 'R'operations, my bad!). Though, it gives TLE on test 83 (17988636) after the corrections are made. I guess

the proper way is to delete brackets in

`[l,r]`

and recalculate`pr`

instead of filling`[l,r]`

with'*'.

On a side note, if I check for the border like this:

`r+1>=border`

, then it gets stuck at test 88 instead of test 83 (17989026)! I think that's just a coincidence and kind of effect of re-run. :)Why is this solution of mine of Div2B giving a TLE? I am performing a maximum of 10^5 calculations. Someone please help!

Here is the link to my solution: TLE Solution

`int j = 1;`

should be

`ll j = 1;`

In problem 2 : Memory limit exceeded. I don't understand how to take care of it. My code is as follow :

## include<stdio.h>

int main() { int i,l=1,j,h,c=0; long long int n,k; scanf("%lld",&n); h=n*(n+1)/2; long long int a[n],b[h]; scanf("%lld",&k); for(i=1;i<=n;i++) scanf("%lld",&a[i]); for(i=1;i<=n;i++) { for(j=1;j<=i;j++) { b[l]=a[j]; if(l==k) {printf("\n%lld",b[l]); c=1; break;} l++; } if(c==1) break; } return 0; }

IN PROBLEM D2I THINK I HAVE A BETTER SOLUTION USING DP RATHER THAN DIVIDE AND CONQUER. MY ALGORITHM:- 1.CALCULATE INT[] DOING INTERGER DIVISION OF B[i] with A[i]. 2.sort this INT[]. 3.Now in a single scan of this array INT we can calculate the answer s.t. At each point we keep track of how many grams of magic powder can make one more cookie. 4.If INT[i+1]=INT[i] we just update this required number to build one new level 5.if INT[i+1]>INT[i] we try to increase INT[i].Can anybody please tell me if my solution is better than the one given as I'm not sure.

Can anyone explain solution of B. I am not getting what is indexing?what does it mean?Thanks in advance

Check out my solution for Problem F. I wrote comments as I was writing the code to illustrate my thought process.

I don't know why my solution gets WA 18297102

There exists a simple greedy solution for problem D . Time complexity O(nlogn) for sorting. And O(n) processing.

19073660

I don't understand the solution of problem D, can anyone explain it elaborately, please?

How do I show this claim in the tutorial :

It is easy to show that if the first day of the year equals to the first day of the week (i.e. this day is Monday) in this year will be minimum possible number of the days off.