The only reason anyone less than international grandmaster would participate in it.

It's already existed in 'Terms of Service'.

Yes, I believe we've helped each participant who reached out to us at [email protected] with details regarding a disabled FB account (generally caused by new FB accounts with no profile information sending friend requests to others, which was activity flagged as being normally associated with fake/spam accounts).

What do you mean by "formal" in this case?

no one limits it, no one cares about it

You can also write a program which takes 1e18 operations. As long as you use the language with free compiler/interpreter and it completes those 1e18 operations in less than 6 minutes. I'm not sure if using GPUs/supercomputers is allowed but you can check rules.

I had the same problem but in windows, the thing is that in windows the size of the stack is 1mb, in Linux and MacOsX it is bigger. This is highly operating system dependent, but can still be changed with a few commands. Luckily the same code that gave me RTE for the stack in windows gave me AC in Ubuntu, but the submition time had passed...

Damnit this was also my issue, except i was on windows.. and i dont even know the flag to increase stack size. Alas, i was too inexperienced. Didn't even notice it was a stack overflow before timed out..

Lesson learned i guess..

g++ -std=c++17 -Wl,-stack_size -Wl,0x10000000 main.cpp works to increase the stack size on MacOS

deleting post since too many down votes — perhaps it was too long or the code wasn't good :)

yeah, me too, and lost my problem C...

Yes, earlier submissions will be rejudged accordingly, we apologize for the inconvenience!

I just submitted and after refresh the page see the announcement... Since the contest is blind they should let anyone resubmit with the new constraints.. The constraints on S before was strictly greater than 0, and someone who puts some assertation may even fail now....

Yes, you're right, thank you for the suggestion. Aside from rejudging submissions that were made at all, we're also working to reset the timer for everybody who downloaded the input but made no submissions, as they could have also been affected (though there are few such cases).

Based on what we've seen, we're proceeding with the round and the existing point values. We believe that, though unfortunate, this issue has had little effect on the balance and results of the round.

It should be working, can you please try again after reloading your page, and send us a clarification if the issue persists?

Let's not discuss the problem from a running contest and wait for the official explanation later on (I have my suspicion about what happened).

Assume $$$P$$$ and $$$Q$$$ to be sorted. Let $$$x_i$$$ be the index of the log driver that set the explosive charge on cluster $$$i$$$. For $$$S = 0$$$, there will be an optimal solution in which $$$x_i \leq x_{i + 1}$$$ for all $$$i$$$.

But for $$$S > 0$$$, this might not be true.

Example : $$$P = [0, 50]$$$, $$$Q = [1, 2, 3, 4, 75, 100]$$$, $$$S = 10^9$$$. In the optimal solution, log driver at position $$$0$$$ covers clusters at $$$1, 2, 100$$$, and the other log driver covers clusters at $$$3, 4, 75$$$.

I'm afraid that would have been unrelated — you should have still received a valid input file, meaning that it would have been an issue with your code.

Two things:

1. You can still solve other tasks.
2. You can learn from the experience.

You can still solve B and score points.

That is correct.

You must not be initializing your array. Declaring globally implicitly initializes the array for you.

It looks like there's a bug affecting some people. We'll try to fix it soon.

My suspicion is that they thought the binary search would work for S > 0 too. Before seeing your example I was convinced that the optimal solution would involve the leftmost driver going to the leftmost groups of logs. Really curious about what the solution & best complexity is for the original problem

B is binary search. Process drivers from left to right. Leftmost driver visits the leftmost cluster, then tries to go right as far as possible. Or vice versa, he goes right then visits the leftmost cluster.

current B (S=0) : http://codeforces.me/problemset/problem/343/C

For each vertex, calculate with DP the following values only considering its subtree:

• total number of possible pairs
• size of the current connected component of uninfected patients
• maximum size of the connected component of uninfected patients
• number of vertices included in maximum size connected components

Now, consider removing a edge connecting a vertex u and it's parent. Optimal way is to connect the maximum size connected component of each separated tree. For the subtree of u, we can just use the DP value before. For the other tree, the DP values coming from the parent can be calculated with rerooting technique. You should take care of case where there is no uninfected patient in a certain tree : any pair is optimal in this case.

Case #1: 3 4
Case #2: 0 4
Case #3: 1 2
Case #4: 3 8
Case #5: 3 12
Case #6: 15 16
Case #7: 193 432
Case #8: 100 180
Case #9: 131955 122400
Case #10: 0 8099820001
Case #11: 3 8099640007
Case #12: 1 6

The thing I missed for quite some time is that I allowed removing edges between two uninfected nodes.

+1, I even wrote an n ^ 4 brute force to stress test but it passed 10k cases against that and I can't figure out what is wrong with it ._.

I'd like to offer another opinion on problem A. By doing this, I'm not in any way discounting your opinion, and in fact I do think your opinion as someone who is more experienced and more invested in the sport should matter more than that of the casuals like me.

That being said, as someone who is in the target audience for easy problems, I enjoyed A quite a bit. In hindsight, figuring out the details of the perimeter updates was tedious, but I guess at the time, I just assumed that was part of the process and didn't think much about it.

Good idea!!

Well, you could skip A2, A3 and C to be honest. I am happy that I did that. A1 and B are pretty easy to write and are not that annoying as some classical bullshit segment merging in A2 and A3.

There is one detail here: you need to provide each contestant a slightly different file, otherwise contestants may cheat by collaborating: each person solves one problem and shares the output file to other people (technically people can cheat by sharing code too, but that is easier to catch). GCJ (in the old format) did that for large dataset, and for small dataset they even generated different files per submission to prevent people from brute forcing the solution.

There was one task in GCJ Final 2009 where Google handled large input file by following: they provided the contestants the script for generating large input, and when submitting, contestant download a seed value as parameter to run the script against. There are still variations on how fast/slow it is on individual computers, but assuming a reasonably large time limit that is still pretty reasonable.

Yeah, I think some problems like this are OK for $$$\ge 24$$$ hour contests, but having all/most of them like this is a little tiring. I managed to solve all the problems, but took quite a portion of the day to do it (due to hunting all the little bugs that caused samples or verification to fail)

Maintain a set of non-overlapping polygons (storing starting position, ending position and perimeter of each polygon would be enough). In the $$$i$$$th iteration, try to combine the $$$i$$$th rectangle with an already stored polygon or store it as a separate one. The technique for combining two polygons is slightly different in A2 and A3. In A3, you will need another set (or other DS) to efficiently find the current height of the polygon at the position $$$x$$$.

Thanks for the suggestions! We'll definitely consider adding public countries of representation in the future.

Not sure of official reason, but in Qualification round some people could not finish downloading input in time constraint. This formula makes it so input is small while having a large test case.

I couldn't download the test data for problem C during the qualification round on time. They reset my timer but they also told me that they wouldn't do it again during the next rounds.

Generating tests with a formula is a nice solution to this matter. However, one has to be really careful coding these formulas.

I'm not trying to dismiss this opinion, I think these are good points, I'm just trying to understand for my own curiosity. I don't remember that many complaints about code execution on contestants' PCs when Google Code Jam did it not too long ago. I genuinely wonder what's the reason of this?

1. My memory is just wrong.
2. People were assuming it as a given for Code Jam and not voicing their concerns, but for Hacker Cup it's a new rule change.
3. People started to use less powerful machines more to participate in programming competitions (e.g. Chromebooks).
4. Competitive programming has become more popular over the last years and as such the number of issues we are hearing about this has increased.
5. Codeforces has become more popular over the last years and as such the number of issues we are hearing about this has increased.
6. Something else.

I just wanted to say something in support of this local-judge format that FBHC uses and GCJ used to use. Note that the alternative for FBHC would be remote-judging without any feedback, as you only get one shot to submit.

1. This format is more contestant friendly in terms of debuggability. I think the fact that OP was able to run valgrind to find the bug already illustrates that they have a lot more debugging tools available. If this were on CF or something, and the bug were some out-of-bounds, they would just get an RTE with no further explanation. (Without feedback, it would just fail entirely.) Being able to debug this way is a fine skill to reward. While there is some pressure, you would've failed the problem if it were remotely judged with no feedback, which would be strictly worse for the contestant.
2. This format is more contestant friendly in terms of tooling. Contestants are free to use whatever tooling or languages they have, without worry about version incompatibility or what standard libraries are available. For C++, I think letting contestants use Boost or Abseil is a great thing! We shouldn't be crippled by this single-file submission format (or even single language), and this is a good way to allow it.
3. This format is more contestant friendly in terms of performance predictability. Contestants are free to create and run any cases locally and have no doubt that the performance in local testing will match the performance on the judge. Each year, IOI puts a ton of effort into accomplishing this by buying matching laptops for the contestants and the judges; this format gives this predictability for free.
4. This format may be slightly friendlier to programmers who have never done competitive programming before. This is mostly the same as the point about tooling: new contestants don't have to learn the idiosyncrasies of the remote environment or how to do the right file-io/stdio setup.

Also, I think the validation file is a great addition; it allows the contestants to ensure their setup is working correctly in a 0-stakes situation. (Old GCJ's small-inputs kind of shared this function.)

As you point out though, there are some drawbacks, but I don't think they out-weigh the benefits:

1. Contestants may prefer the well-managed/well-configured environments of remote judges, e.g. to set stack limits. For the record, I don't think this is a valid excuse for any advanced contestant; at the top level, you need to be able to locally test max cases anyways, and you should totally be able to configure your environment for that. On the other hand, this may disproportionately impact novice programmers who don't have a great mastery of their local toolchain/environment. I'm not sure how this weighs against not having to learn the intricacies of the remote environment; perhaps CP nowadays is sufficiently "plug-n-play" that running code remotely "just works" for a beginner. I think the best solution to this, though, is to use some online service like repl.it to run your code; these are designed to be beginner friendly, and give you a nice prebuilt VM to use. These services are plentiful and accessible enough that I think anyone learning to program can easily find one to use. (I think repl.it has file upload/download too.)
2. Some contestants may have beefier computers/setups which give them an unfair advantage. I think this is a real phenomenon which may impact results, but I'm not quite convinced that it's a big deal. First, 6 minutes is very generous; any solution that could've passed in a blind remote-judging scenario will almost certainly run within 6 minutes on pretty much any machine, so anyone who would've succeeded anyways will continue to succeed. On the other hand, it is true that people may be able to squeeze solutions that otherwise would be too slow by parallelizing or using a bigger machine. I have a few responses: first, writing parallel code is a programming skill that seems fine to reward. Second, this can be partially mitigated by choosing problems where the difference between the intended solution and the slow solutions are larger, e.g. polynomial vs exponential. In practice, I don't think we see people renting out AWS machines to pass problems, so I don't think this is a huge problem.

Overall, I think this format is net positive for contestants, and I really hope FBHC keeps it (especially with validation sets).

I actually implemented this after I finished (for fun/for verification), you can find a screencast here: https://www.youtube.com/watch?v=CwEJmC3RWOI.

It was good that they had a problem in the qual round that forced us to deal with the stack limit. But for some reason, even though I set my system limit to the maximum and passed the qual round problem, I still got a segfault in R1. Only with some extra g++ options did it pass. At least I know how to set my compiler invocation properly now!

I do think it's good that the format is different. It could lead to more variety — like using more obscure languages or third party libraries, or more room for precomputation for some kinds of problems. It's just that the execution makes it stressful.

		auto lpt = ls.lower_bound({l[i],{0,0}});
		auto rpt = ls.upper_bound({l[i]+w[i],{0,0}});

You may need to give sufficiently big values instead of {0,0}. I have made an exact same mistake.

One funny thing is , for the first problem A1, I had initially thought of the same approach as Errichto. Then I thought it won't finish executing under 6mins.

In his video , his computer (which is a lot faster than mine in terms of performance) finished the test in 3mins. I think in my case it would have been a very close call if I had implemented Errichto's solution.

Too bad, the binary search + dp solution is flawed. :P

It fails because you took max of H every time. think of a smaller height between two bigger ones, it will increase the perimeter.