The comment is hidden because of too negative feedback, click here to view it

In my elementary school, it is also a math final examination. I don't care the score, but I care my father's stick fore when I don't get full score. All in all, I will have this contest in my quilt, and beat everyone who see this comment!

Hoping not to turn Green today :D

There's a huge gap from July 2013 to April 2014. He must have trained very hard in that time.

I wish to achieve something like that :') ancien, thanks for making us notice it

Hey, happy birthday.

happy birthay amigo

it is sorry.

It's not green, it's cyan.

You will be blue again, I think.

Oh my god. There is no JIBANCANYANG's message here!!!

You'll make it, xiaoai. ;)

I probably have missed blue this contest, at least I am diamond in league of legends!!!

Did you light a candle? It may work :)

The only way to learn is to learn from mistakes :)

All the best man!

Hello,girl.Can I get your facebook?

Hoping that you will learn english

Good luck and welcome to CF community!

https://www.youtube.com/watch?v=dQw4w9WgXcQ

Yes, the contest is open for all! All the best. :D

this looks like a fake acc

Also in the last 5 days, 4 contests in Codeforces, among them 2 contests are being rated. It's amazing !

In second code, mid value in run(l, mid) is not same as that of in run(mid + 1, r). You can just simulate the function calls till depth 2 or 3 and you will get to know more clearly!

In the second code after running run(l, mid) recursion the mid variable will be different for run(mid + 1, r) (because it was modified in the other case). And in the first code it remains the same.

global vs local variable.

if you want to keep mid as a global variable, you have to reassign it after the first recursion so it has the correct value again.

int mid;
void run(int l,int r)
{
    if(l==r) ;
    else
    {
        mid=(l+r)/2;
        cout<<mid<<endl;
        run(l,mid); // after this runs, mid will have a different value
        mid=(l+r)/2; // reset the value before the next recursion
        run(mid+1,r);
    }
}

i'm only 9th 'cause Shokoladnitsa sucks :(

ХОЧУ БОЛЬШЕ МИНУСОВ

http://codeforces.me/contest/682/submission/18554461

U need to go to KFC to solve such hard problems.

D can be solve using dynamic programming. See my submission for details.

And I thought you were about to say something humourous :P

fake accounts , CodeForces must reduction of this phenomenon

The exact same thing happened to me and I started solving D in the mean time. When I came back to have a look at C for the last time, I realised that I misinterpreted the u,v nodes and then I was able to solve it in 5 mins. Truly Facepalm!

Same here. But thankfully realized that the figures in explanation of samples won't make any sense in such an interpretation, hence was forced to look back and check. Still, the notation used in statement is pretty unusual.

when sum(root,V) < 0 you should make it 0

Wrong solution:

3
1 10 15
1 -100
2 115

your solution doesn't delete any leaf, but need delete leaf number 3.

You don't need to check sum(root, V). This is because, the question states that a vertex V is not sad if sum of weights from node V to any node u in it's subtree should be <= a[u], but you are considering only sum from root. There may be a case where weight of root to all it's children is negative. So, we don't have to count the negative weights. For eg., Consider this graph : 1->2->3 Let wt(1->2) be -10, and wt(2->3) be 10. a[1] = 1 , a[2] = 10 , a[3] = 1. Here, vertex 2 is sad, because path 2->3 has weight 10, but a[3] < 10. However, you will end up considering weight as 0, because you will be adding the weight of 1->2 as well, which is not required here. Hope you understand. I haven't taken a look at the test cases yet, but I too had a WA on pretest 4, and this was the change I made to get Pretests Passed verdict. Hope this helped!

You should combine 1 with [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15..]

More clearly:
1 + 4 = 1 × 5
1 + 9 = 2 × 5
1 + 14 = 3 × 5
...

Even more clearly:
1 + (4 + 0 × 5) = 1 × 5
1 + (4 + 1 × 5) = 2 × 5
1 + (4 + 2 × 5) = 3 × 5
1 + (4 + 3 × 5) = 4 × 5
...

Do you get it?

You can fix two points, and then run ternary search to find the maximum. It is n²logn. This was the first time I solve E, but I didn't manage to solve C, D for some reason :(

Maybe you forgot about using long long

In A, the result can be larger than 32 bit int

Take a look at my graph and keep fighting bro!! We all have bad days :)

maybe my solution could help?

http://codeforces.me/contest/682/submission/18566989

I did a dp on [i][j][used][using] where used is the # of segments started so far and using is whether a segment is running...

I have no idea if this actually works; I just BSed a solution while being frustrated about missing TC 3 on C and it ended up passing pretests lel

Dp :-?

There's a pretty simple dp solution: http://codeforces.me/contest/682/submission/18566989

The only solution with hashing i can think of is if you used binary search + hashing when "taking" a segment, to quickly find out for how long are both strings the same. Not sure if that solution would be fast enough, though.

And you got +67 rating, your family must be proud of you now :)

Are u referring to KFC logo being red?

I think you should get the convex hull, fix two points, then ternary search the third point for the largest triangle then do the scaling

Read about Kadane's algorithm (maximum subarray problem) first (it is very easy — a 5 minute reading).

Now let's take a look at some internal node v_k. There is a path from root (v₁) to that vertex:
v₁→...→v_k

The only thing we need to determing is whether v_k makes feel sad ANY of the nodes on that path (that sentence is the key to understanding; read it again till everything is clear).

The node v_k makes some of the nodes on that path feel sad only when
a[v_k] > max(d(v₁, v_k), d(v₂, v_k), ..., d(v_k - 1, v_k))

Kadane's algorithm helps with finding max(...) value fast during dfs.
dfs(v₁)
maxDist = max(0 + d(v₁, v₂), 0)
↓
dfs(v₂)
maxDist = max(maxDist + d(v₂, v₃), 0)
↓
dfs(v₃)
maxDist = max(maxDist + d(v₃, v₄), 0)
↓
...
dfs(v_k - 1)
maxDist = max(maxDist + d(v_k - 1, v_k), 0)

If v_k makes someone sad — it is a bad vertex and we have to remove it with all of it's descendants (using the same dfs we calculate how many children every node has).

How is it any different from LCS? Am I wrong in assuming that the only added condition is that the answer of lcs >= k

http://codeforces.me/contest/682/submission/18564850 Got WA :( Can someone tell what is wrong with this soln?