这是一个正经的求助帖。标题是瞎写的。

在某群看到这个玩意，因为我已经几个月没碰 OI 和数学了，所以我不知道这个东西怎么做，或者说有没有做出来的可能。

某群群友告诉我这是钓鱼题，但是我还是很好奇能不能用程序跑出来。

以下是我写的程序。因为 C++ long long 炸了，不想写高精，所以我用的 py。

import sys
sys.setrecursionlimit(int(1e6))
# 递归深度限制为 1e6

memory = {}

def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a % b)

def reduced(x):
    if x[1] < 0:
        x[0] *= -1
        x[1] *= -1
    g = gcd(x[0], x[1])
    y = (x[0] // g, x[1] // g)
    return y

def sub(a, b):
    a = reduced(a)
    b = reduced(b)
    l = a[1] // gcd(a[1], b[1]) * b[1]
    return (a[0] * (l // a[1]) - b[0] * (l // b[1]), l)

def f(x):
    if memory.get(x) != None:
        return memory.get(x)
    x = reduced(x)
    if x[0] < 0:
        memory[x] = (-x[0], x[1])
        return memory[x]
    else:
        y = f(sub(x, f(sub(x, [1, 1]))))
        memory[x] = (y[0], y[1] * 2)
        return memory[x]

if __name__ == "__main__":
    print(reduced(f((3, 1))))

然后 py 也炸了。