Maybe because it's round 314.

As a remainder PI = 3.1415...

What is the point of hoping for something like this; this is not IMO. Instead, you should be hoping for an interesting and varied problem-set — one consisting of other things as well.

According to this logic, first Pi round was 3, but was it?

ლ(ಠ益ಠლ)

I like this picture very much but what does it mean here??????????????? :|

so cute ^_^

В америке в одно из штатов число Pi равно четырем. НИЗОЩИТАН!

.

of course

Nice try Internet Explorer(or Edge)... Very nice try...

Codeforces Round #FF also instead #255.

Why are you so diao?

i do think geometry is your dish.

You were wrong :D

It will be crazy, I guess.

Тут: http://codeforces.me/contests время тоже два с половиной. Видимо, на почту оповещение неправильное сформировалось.

paradoxical :p

What bothers me usually is when authors wish high ratings for all of the participants :-/

So lock in the last 5 minutes, and spend 2hr 25 minutes before that making sure your answer is correct :)

You solved C in 3 minutes!!! What is this sorcery?

Six problems I guess :p

Не думаю что на CF у всех проблемы со зрением.

сегодняшнЕм

СПАСИБО! И ТЕБЕ УДАЧИ MAXIMAN!!!

Неужели на CF появился более упоротый человек, чем я 6 лет назад?

Nice idea !!

numbered rounds of Fibonacci numbers: round #Fibonacci

OK. Good Luck :)

Максииим, привет!

I'll be Grey in no time

I guess you're not finding the bridges correctly. I got WA 19 because of a caveat in my solution, I only check for edges that definitely are on the shortest path ONLY from the start and the end, but there could actually be bridges in the middle of the path too. An example edge formation , start = 1 , end = 8 : 1 2 1 3 2 4 3 4 4 5 5 6 5 7 7 8 6 8

The edge 4 5 is definitely on the shortest path since it is a bridge in the shortest path graph. Hope it helps .

Is there a solution without modulo calculations?

Was my solution also hacked because of modulo? It would be quite strange since I used both overflow hash & modulo. I even changed modulo after getting hacked, but still got WA (on your hack).

What sense not to be hacked if solution is wrong?

I'm wondering if his code gets accepted after all. :/

me to.

You can support 2 maps, left and right. When you iterate over the sequence, you should add left.get(a[i] / k) * right.get(a[i] * k) to the answer, and then add current element a[i] to the left map and remove it from the right one.

k * k overflows.

EDIT: Result (num) could overflow too.

Ships cannot touch each other.

How do you calculate the number of ships that can be placed into one interval?

Idea is ok. Alternative solution is to do binary search over result.

I processed the queries from last to begin and kept a disjoint set for the connected parts and instead of splitting merging.

Apparently, you can't have 2 ships RIGHT next to each other, so when calculating number of ships possible in an arrangement, you had to make sure you left 1 space in between each(so you had to add extra logic for both inside the interval, as well as between consecutive intervals.

My solution was binary searching for the answer. You fix the amount of shots fired then you mark those cells. Once you've marked some cells as shot you can get the maximum amount of ships that can be placed in O(N) using greedy approach.

1) Let's find the asnwer by binary search (answer — k) 2) Each iteration of search we will check by function CHECKING that says TRUE if we can't place all ships with k turns and FALSE if we can. If True, you should make left_border=k, and if False — right_border=k+1 3) How does CHECKING work? Make a vector of field and fill it by 1(free place) and 2(place where Bob shooted). Then in cycle just greedy fill it by ships from left to right and calculate its total. Return total<number_of_ships 4) PROFIT!

The same thing happened with me. I spent 2 hours making numerous test cases and my code was working for all of them.
So , after the contest , upon asking adurysk I realized that two ships could not "touch" meant they couldn't be adjacent . Facepalm

Needed to change (N/K) to (N+1)/(K+1) to get it Accepted :P

My F was O(n ^ 2 + nk) i think

two maps

m1[x] = y <=> count of subsequence of length one finishing at x equals y

m2[x] = y <=> count of subsequence of length tho finishing at x equals y

So, we getting num a. Then ans += m2[a/k]; m2[a] += m1[a/k]; m1[a]++

DP; you put the pairs from largest to smallest. States are "the blocks you put so far are in the interval [i,j]". There are just 3 possible transitions from any state and you just need to check if any in/equality becomes invalid for each of them.

The simplest implementation is O(KN³), which definitely passes.

dp[left][right] — in how many ways can we fill blocks 1... left and right... 2N with small numbers (numbers lower that those left for interval left + 1... right - 1. We must consider 3 cases: adding two new equal numbers in left + 1, left + 2, or in left + 1, right - 1, or in right - 2, right - 1. For all 3 cases we must check is everything would be ok for them — those two places are equal to each other but lower than remaining places in left + 1... right - 1.

use tab indent to understand your bug!!

One way is to find result by binary search. Then, we mark some cells as blocked and we need to count maximal possible number of ships. Say if you need more explanation.

The rough idea is to maintain the maximum number of ships you can put on the board.
Notice the fact when you hit a spot, you are splitting an interval(between 2 previously-hit spots) into 2 intervals. With that, you can calculate how many ships can be put on the original interval and on these new 2 intervals, and update the number we're maintaining.
Use std::set to store previously-hit spots.

Let's use a some set, which will keep disjoint segments.

Also let's keep some value T which means what is the maximum number of ships we can arrange on a board.

When we add a segment to the set, we must increase T by some value x, which means the maximum number of the ships we can arrange on current segment. This number is equal to (len + 1) / (a + 1) where len is a length of the segment and a is the length of the ship

At first let's add segment (1, n) to the set.

So, when the cell c is coming, let's find a some segment(l, r) which keeps c (l <= c <= r). We decrease T by (len(l, r) + 1) / (a + 1).

Then we add segments (l, c - 1) and (c + 1, r) to the set and increase T by appropriated values.

If we processed current operation and T is less than k, answer will be equal to the number of operations we processed already.

For keeping segment we can use a simple set of pairs. My solution: 12365410