as far as I know, there is no mirror contest, the problems are usually posted after the contest starts (PDF), usually the problems are posted to COJ or URI judges some days after the contest.

The contest is held onsite, so contestants will not have access to the discussion here on codeforces.

For problem L: If the number of blocks (not meters) you have to walk in one direction is much smaller than in the other direction, then you have to "kill time" somehow. There are three ways to do this: Keep zigzagging between two adjacent streets near the starting point (maybe in a 5-meter block), or find the nearest 1-meter block (in either side), zigzag there and then go to the end vertex. So for each direction there are only three possible plans, giving nine plans in total. It is possible to try them all.

For K, the intended solution was indeed brute-force + maxflow, but there is an easier solution: Create two vertices for each empty cell, one vertex for each cell with a circle, and connect two vertices if the corresponding cells share (exactly) one edge. The solution is Y if and only if this bipartite graph has a perfect matching: If there is a matching, contracting the two vertices corresponding to each empty cell gets you a graph with maximum degree 2 and the correct vertices of degree 1. Conversely, if there is a solution, then there is a matching by just looking at the segments which cross cells on the board.

This contest already finished, so we are not able to submit any problems :(

When will the problems be uploaded to some other OJ? Or when will we be able to submit the problems in URI?

You can try to "reverse engineer" the way the string was built. Think about the last typed character, if the current string is s₁ s₂ ... s_n either the last character you typed is s_n and it is a consonant or is s₁ and it is a vowel. On the first case the string previously was s₁ s₂ ... s_n - 1, on the latter s_n ... s₃ s₂.

The trick is that it's impossible to construct a string that starts with a consonant and has a vowel elsewhere and if the string has only consonants there's only way to type it. With this observation even a recursive solution is fast enough.

# Paulo Cezar P. Costa, ICPC-LA 2017, Buggy ICPC
#!/usr/bin/env python3


def is_vowel(c):
    return c in "aeiou"


S = input()
N = len(S)

# we will deconstruct the string trying to track where the bug might have
# kicked in but instead of actually changing the string we just use some
# variables to represent the current state of the string, we can do that by
# keeping the positions of the first and last character of the current string
# on the original one..
begin, end, ans = 0, N - 1, 0
# the amount of vowels in the current string is also quite handy
vowels = sum(is_vowel(c) for c in S)

while True:
    if begin == end:
        ans += 1
        break

    # since we are only handling indices and sometimes we'll reverse the string
    # we need to adjust this delta here to figure out in which direction we are
    # moving when we remove a character. e.g. if begin > end and we remove a
    # character from the end we should actually increase end.
    delta = 1 if begin < end else -1

    start_with_vowel = is_vowel(S[begin])
    end_with_vowel = is_vowel(S[end])

    if not start_with_vowel:
        # it's impossible to construct a string that starts with a consonant
        # and has a vowel elsewhere, since every time we add a vowels it goes to
        # the beginning of the string. on the other hand, if there are no
        # vowels, the bug would never kick in hence there's only one wayto type
        # the string (by always adding the consonant to the end)
        if vowels == 0:
            ans += 1
        break

    if end_with_vowel:
        # S starts and ends with a vowel, so there is no choice..
        # the vowel at the beginning was actually added last, we need to
        # reverse the string and remove the vowel from the end, new state is
        # (end, begin+delta, vowels-1)
        begin, end, vowels = end, begin + delta, vowels - 1
    else:
        # S starts with a vowel and ends with a consonant, we have two options:

        # if the vowel was added last, this means the bug kicked in and we need
        # to reverse the string and remove the vowel from the end, getting into
        # the state (end, begin+delta, vowels-1). But by doing this we already
        # know that the new string will not start_with_vowel and this means it
        # only adds to the number of ways if there are no vowels left
        if vowels == 1:
            ans += 1

        # otherwise the consonant was added last and we simply remove it and
        # keep counting
        begin, end = begin, end - delta

print(ans)

The explanations of problem K has several missing pieces. We need to brute force each possible subset of points to build the bipartite graph which is combinations of 14 in 7 (3432) at most. Also we need to run, not a standard flow, but a flow with lower bound or solve the equivalent circulation problem.

Why in the statistic of this problem there are 0 submissions / 0 solutions when 2 teams solve the problems?