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!
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.
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.me/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 2i. To remove all nodes between l and r all 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.me/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...
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.me/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.
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.me/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
indicates i th bracket matches with j th bracket. I have used four stacks (left_part
to store left part of the string,Left
to store the positions of the brackets ofleft_part
, similarlyright_part
andRight
), though it can be done more effortlessly.next_right
andnext_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]
andnext_left[r]=next_left[l]
because in a certain moment
r+1
doesn't represent the next position ofr
after some deletions.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;
Check out my solution for Problem F. I wrote comments as I was writing the code to illustrate my thought process.
There exists a simple greedy solution for problem D . Time complexity O(nlogn) for sorting. And O(n) processing.
19073660