You can subscribe to TopCoder's Google Calendar, and then set up your own notifications any way you please:

https://calendar.google.com/calendar/embed?src=qshn4jb7pq3f8l46nvvilj5c6o%40group.calendar.google.com

Calculate the probability of picking each item and then apply bitmask dp on states.

http://blog.quantitations.com/stochastic%20processes/2013/02/07/expected-number-of-steps-of-a-markov-process/

Answer will be dp[0]

Bfs on edges definitely works (just passed in practice room). I doubt there's a simpler way to do it since this is already pretty straightforward.

For div2 medium, you can use dynamic programming (there are non DP ways to solve it as well). The state consists of the following:

1. the index of the rectangle you are currently processing
2. the "intersection rectangle" of all the rectangles you've included so far

For example, if I have rectangles 0,4,6,8 (the 0 is x1, the 4 is y1, the 6 is x2, the 8 is y2) and 5,2,9,5, then the intersection rectangle would be 5,4,6,5.

So for each state, we either try to include the current rectangle, or we skip it. We take the best of those two results. When we include the current rectangle, we have to calculate a new intersection rectangle based on the current state's intersection rectangle and the rectangle at the current index. If there's no intersection rectangle for these two, then we can't use this rectangle. Otherwise, we pass this new intersecting rectangle to the next state.

We wanted to give a chance to the newbies too as the camp has three divisions of difficulty. Moreover, it is easy to verify 2 genuine coders out of the Div II list easily, their identity and information will be required for booking their bootcamp tickets. Also as per the rules, individuals are only allowed to have one account. If they create a new account, all of accounts may be suspended. Rest assured we will make sure deserving and genuine competitors get the chance

The key subtask is: given numbers x, b, and a set of numbers y_i, what is the smallest number of form x xor (xor of some subset of {y_i}) that is  ≥ b?

If we solve that one, we can apply it inside the standard DP to find the LIS.

And to solve the subtask, we iterate over which bit will be the first difference with b, and then we have a subtask: a set of numbers y_i, find a xor of its subset with certain higher-order bits and the remaining bits as low as possible. This is essentially solving a system of equations in Z/2Z, so we use Gaussian elimination in the right order (from higher bits to lower bits).

Yes, actually the proof is not so hard.
Suppose that there is a valid path, . v_i is the coordinate of where the frog is on i-th step. Note that the place v₂, v₃, ..., v_k - 1 is not necessarily on edge of the square.
Let's think about "modifying" the path with following way, that it remains still valid, and the length of path is same or improved.
Look at the following picture: This represents two cases (left one is case #1, and right is #2).

The first case is that "x and y is both increasing or decreasing". In this case, you can compress the path, from , to . If you do this, the number of vertices decrease by one, and also the distance remains greater than or equal to d.
The second case is the other pattern. Without loss of generality (because you can rotate arbitrarily), suppose that the y-coordinate of v_x + 1 is greater than v_x one and v_x + 2 one. In this case, if you change the y-coordinate of v_x + 1 into n - 1, obviously the distance will increase or stay equal so distance remains greater than or equal to d, and obviously the number of vertices doesn't change.
If you repeat the process until no change occurs for any x, v₂, v₃, ..., v_k - 1 will be on the edge of the square. Proved.

Simple trick for expected value can be used here — Dp[mask] = turns to complete game from mask. Go in backward direction with base case Dp[S] = 0. Acyclic recurrence code dp