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 ^_^

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.

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

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.

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

You can view small inputs after the contest. Scroll to the end here: 12373900

In the if at line 29 you should add :

p[abs(arr[i])]-=arr[i];

This is because the person left, but you never marked him coming in. So in the beginning of the iteration you added arr[i], marking him leaving, once you understand that he's been in all along you should make up for his coming.

Feel free to ask questions :)

Your if "if(p[abs(arr[i])]<0){" should be done at most once for every arr[i]. You have WA for test

3
- 5
+ 5
- 5

My solution is to dijkstra 2 times, one from s and one from t

for each edge u->v if dist(s->u) + c(u,v) + dist(v, t) == dist(s, t), u->v may be a "sure" edge

Take all those edges and eliminate the direction, we can find the bridge by simple DFS.

Note that there may be multiple edges between two vertexes. I failed E during the contest because of that :(

You could easily count how many times a given numbers repeats using a map, then it's basically C( [amount of repetitions of this number], 3) which is equal to [reps * (reps-1) * (reps-2)/6] when you simplify the formula.

 for(int i=0;i<n;++i)
        {
            scanf("%d",&t);
            if(k==1)res+=(a[t]*(a[t]-1))/2;
            ++a[t];
         }
cout<<res;

For k=1 this program gives correct anserws. PS.a is map<long long,long long>

please paste your code here.

That's because, this rating shows the measurement of competitive programming skill which is different from problem inventing skills. There are many cases where enough knowledge doesn't help the subject to do better in competitive programming.

No.

it=s.upper_bound(mp(mov[i],-1)); should be it=s.upper_bound(mp(mov[i],n+1)); in order to find the intersecting interval after decrementing it. If you have an interval that starts at mov[i], upper_bound will return it and decrementing will miss it.

Yup, Bridges in the "shortest path graph" are guaranteed to be on every possible shortest path.