**13:16**- 15 minutes before the start. Today's lineup: ACRush, liympanda, Louty from China, dzhulgakov and Klinck from Ukraine, PaulJefferys from UK, bmerry from South Africa and rng_58 from Japan.

**13:18**- ACRush, liympanda, bmerry and PaulJefferys are returning participants of the TCO onsites, while Klinck, dzhulgakov, Louty and rng_58 are here for the first time. Klinck has been participating in TopCoder for 7 years, though, and has almost always been near the top of "Submission accuracy" rating. The effort has finally paid off!

**13:23**- watching the screens of dzhulgakov and Klinck today.

**13:25**- the introduction has started.

**13:29**- 1 minute before the start.

**13:34**- the easy problem: you have up to 50 election districts, and the voting happens the following way: in i-th district, there are

**voters**[i] voters and each of them votes for somebody. Then, for each district the candidate who's got the largest number of voters wins. In case of a tie, nobody wins. You are asked about the smallest number X such that when X people vote for your party's candidates, no matter which X people, you're still going to have strictly more than half of all winners.

**13:39**- the solution is quite easy and suggested by the examples. In the worst case, in order NOT to win you can get all votes in one half of the districts (the largest ones), and one less the half votes in all other districts. This requires care about ties, and different handling for odd/even number of total districts. Most people will submit something like this, but I expect an eventful challenge phase here.

**13:40**- submissions from PaulJefferys, rng_58, dzhulgakov and ACRush. Only rng_58 have opened the medium.

**13:41**- syg96 suggests a solution that will probably have less corner cases: iterate over how many district wins, draws and losses are we going to have (in the worst case of not winning). It's quite obvious that wins should go in the largest districts, then draws, then losses. Then just take the maximum over all scenarios where we don't win plus one.

**13:42**- the medium problem: what is the smallest area of a square with vertices in lattice points that contains exactly

**n**lattice points inside?

**n**is up to 10^12.

**13:44**- a submit on easy from Klinck.

**13:44**- suppose the side vector of the square is (x, y). Then the number of lattice points inside is x^2+y^2-2*gcd(x,y)+1, according to the Pick's formula.

**13:48**- this should be equal to

**n**. Since we need to minimize the area, we need to minimize gcd(x,y).

**13:50**- a lot of numbers are representable as sum of two squares. More precisely, all prime factors of form 4k+3 should have even exponent in the prime factorization.

**13:51**- meanwhile, PaulJefferys have resubmitted the easy and liympanda has submitted it.

**13:56**- so I would guess the following should work: we iterate over possible value for

**g**=gcd(x,y). When that value is fixed, we get x^2+y^2=n+2*g-1. We substitute x=g*p, y=g*q, then we get p^2+q^2=(n+2*g-1)/(g*g). So we need to check if there's a sum of squares of relatively prime numbers equal to the given number. And for that, we can just do bruteforce since we'll need to check sqrt(n) values for g=1, sqrt(n)/2 values for g=2, and so on, for the total of sqrt(n)*log(n) values. This should run fast enough.

**13:56**- dzhulgakov seems to have a working solution in terms of time limit, but it doesn't pass the examples.

**13:57**- meanwhile Louty submits the easy, and everyone is working on the medium, including bmerry who didn't submit the easy.

**13:58**- dzhulgakov fixes his bug, but still unsure about TL. ACRush has already submitted some time ago.

**14:00**- rng_58 submits the medium, too.

**14:01**- dzhulgakov speeds up his code from about 1s to about 0.2s, but seems to give WA now. He's looking into STL docs now.

**14:03**- rng_58 have opened the hard, dzhulgakov has found his bug (int instead of long long). Now his sol works in 0.2s and seems correct. Going to submit?

**14:04**- dzhulgakov submits.

**14:06**- the hard problem: you are given a 44x44 rectangle of 'R', 'G' and 'B' characters. You consider all possible ways to take two (possibly intersecting or partially lying outside) kxk squares, then take all of the jewels inside at least one of those squares, then discard some of them and place all the rest in one chain. How many different chains can you get, modulo 10^9+9, if two chains that are reverses from each other are considered equal?

**14:11**- the obvious idea for the first step is considering all pairs of two squares, and recording how many Rs, Gs and Bs are there in their union. This can be checked in O(1) for each pair if we precalculate partial sums of upper-left rectangles.

**14:11**- meanwhile, liympanda and PaulJefferys also submit the medium.

**14:13**- ACRush still didn't open the hard, he's checking his solution for the medium. People watching his screen say he didn't find any bug, he's just checking it very thoroughly. Maybe he knows about a problem but is not sure if it can be triggered by the possible testcases?

**14:15**- then what we can do is iterate over possible values of how many Rs and Gs are there going to be in the chain. For each such pair, we calculate the largest amount of Bs possible, and now we need to calculate the number of chains with this many Rs and Gs and at most this number of Bs in O(1).

**14:17**- if we forget about "up to reverse" condition, the formula is quite straightforward: ((R+G) choose R) times (1+((R+G+1) choose 1) + ((R+G+2) choose 2)+...+(R+G+B) choose B). How do we find that in O(1)?

**14:19**- I guess we can just precalculate that for all values of R+G (which are up to 2*44*44 in total) and B (up to 44*44), that should be fast enough. So the only thing to deal with is "up to reverse" condition.

**14:24**- And this is dealt with as usually by finding how many stay the same up to reverse (this means looking at a sequence of length n/2, with probably special casing for the middle cell when n is even), and then dividing all the remaining amount by 2 since all others split into pairs.

**answer_up_to_reverse**=(

**answer**+

**answer_thats_same_as_reverse**)/2. This can also be viewed as the Burnside's lemma application.

**14:24**- meanwhile, ACRush has resubmitted the easy which drops him to 5th in the current standings. Everyone has submitted the medium, bmerry still didn't submit the easy. rng_58 is first, dzhulgakov is second.

**14:29**- now that we seem to have solutions for all problems, let's just watch what the contestants do.

**14:31**- ACRush, rng_58 and bmerry seem to be coding something similar to the above solution. Most others are thinking. dzhulgakov is rechecking his easy solution.

**14:33**- or maybe he's not? he has the easy code open, but maybe he's thinking about the hard on paper?

**14:37**- some discussion of the easy between the spectators suggest it's quite hard to do it by considering all cases - the solution suggested by syg96 above (and dzhulgakov has implemented something very similar) is indeed the way to go.

**14:41**- rng_58 is already testing his hard, not sure if it's the version without "up to reverse" or the final one.

**14:42**- rng_58 has a bug in counting the number of Rs, Gs and Bs: x and y swapped in one place.

**14:43**- liympanda resubmits the easy as well! This is going to be a hell of a challenge phase.

**14:45**- everyone except dzhulgakov and liympanda is working on the hard, but it seems like not many are close enough to submit in 10 minutes.

**14:47**- Louty gives up. bmerry, ACRush and rng_58 are all debugging one different example cases. Paul and Klinck are still coding.

**14:48**- Klinck gives up as well, tests his medium. Maybe giving up now will actually prove crucial for the challenge phase?

**14:49**- or maybe not! rng_58 passes all example cases, tests for TL...

**14:51**- and he submits!

**14:52**- and ACRush submits, too. He's above but the difference is less than 5 points. I guess challenges WILL be important, just not for everybody :)

**14:54**- ACRush still looking at his hard - this is probably a bad idea. Should be working on challenge cases instead. Nobody else submits, the coding is over.

**14:56**- PaulJefferys is preparing a large random testcase for ACRush and rng_58's hards. We'll see if those seem to be correct at the very beginning at the challenge phase. That will probably affect the further challenging strategy of everyone.

**15:00**- most people went for 250s, bmerry is reading 500s. Paul decided not to blind-challenge the hards.

**15:01**- ACRush successfully challenges Louty's solution!

**15:02**- and there goes dzhulgakov's easy.

**15:04**- the challenge case for both is "10, 10, 5, 4, 1" with the correct answer of 25. The trick here is that one needs to win the first two and draw the FOURTH in the worst case, while dzhulgakov only considered winning some largest ones and drawing some next largest ones.

**15:08**- just one minute left, still no challenges on the hards. C'mon, Paul!

**15:10**- Paul looked at the hards but decided not to challenge. ACRush got -25 in the final seconds.

**15:10**- let's wait for the systests...

**15:16**- ACRush seems to be pretty confident in his solutions. His only concern is the doubles he uses in the 500.

**15:17**- ACRush has also told me that he didn't test his 1000 at all except the examples, but he doesn't think there'll be any TL issues.

**15:18**- I think I will take a break now before the results are announced.

**16:00**- rng_58 is the champion! ACRush's hard, Paul's easy and liympanda's medium failed, all others passed.

**16:01**- wata is the Marathon champion! chokudai is second, doudouille is third. Go Japan!

**16:03**- as expected, Margarita is the Mod Dash champion!

**16:05**- and djackmania is the Studio champion! I think that's it for today's live coverage. However, please check this blog later for some videos of the event.

which algorithm book do you recommend for preparing for this kind of problems?

ReplyDelete