Will the scoreboard of previous round ever be fixed?

Does anyone from any APAC of this year get interview call?

just curious to know.

The scoreboard is still broken.

Please at least mention the number of people who solved each problem in the analysis after the contest ends.

DP everywhere.

Can anyone tell me why the following code for Problem A is wrong?

The idea is to first find the repeated length r of A^n mod P,

then find the value of N! mod r.

Then the result will be A^r mod P.

T = int(raw_input())
for t in range(1, T+1):
    A, N, P = map(int, raw_input().split())

    if A % P == 0:
        print "Case #%d: %d" % (t, 0)
        continue
    
    result = []
    product = A % P

    while product not in result:
        result.append(product)
        product *= A
        product %= P

    # result is of size at most P

    repeat = len(result)

    # compute N! mod repeat

    if N >= repeat:
        ans = 0
    else:
        ans = 1
        for i in range(1, N+1):
            ans = (ans * i) % repeat
            
    print "Case #%d: %d" % (t, result[ans-1])

How to solve problem A , Is that so easy :(
I didn't get how to approach that problem.

Here is my editorial.

Problem 1. A^(N!) = (...(((A^1)^2)^3)...)^N

def solve(A, N, P):
    for e in xrange(1, 1 + N):
        A = pow(A, e, P)
    return A

Problem 2. Draw an edge (i, j) if on some card i is paired with some card j. There are N-1 unique edges. We want the lowest sum of edges such that we form one connected component with the edges — this is just an MST.

class DSU:
    #details omitted
    
def solve(N, A, B):
    cards = zip(A, B)
    edges = [(min(c[0] ^ d[1], c[1] ^ d[0]), i, j)
             for i, c in enumerate(cards)
             for j, d in enumerate(cards) if i < j]
    edges.sort()
    dsu = DSU(N)
    return sum(dsu.union(i, j) and cost
               for cost, i, j in edges)

Problem 3. Let dp(r1, c1, r2, c2) be the answer for the submatrix with those corners. For each of the (r2-r1) + (c2-c1) cuts, calculate the answer recursively. It depends on being able to query the minimum value that occurs in r1, c1, r2, c2.

def solve(A, R, C):
    def lookup_min(r1, c1, r2, c2):
        #details omitted
    
    @memoize
    def dp(r1, c1, r2, c2):
        if r1 == r2 and c1 == c2: return 0
        ans = None
        for r in xrange(r1, r2):
            ans = max(ans, dp(r1, c1, r, c2) + dp(r+1, c1, r2, c2))
        for c in xrange(c1, c2):
            ans = max(ans, dp(r1, c1, r2, c) + dp(r1, c+1, r2, c2))
        return ans + lookup_min(r1, c1, r2, c2)
    
    return dp(0, 0, R-1, C-1)

Solutions & Explanations have been updated here: http://ckcz123.com/blog/posts/kickstart-2017-round-g/