代码

// This code is AI-generated. (AI 生成的代码)
// NOIP2018 填数游戏 (enhanced): closed-form answer by min(n,m) and the gap.
// Bypasses libc: parse n,m straight from the DuckInfo input buffer and write the
// result into its stdout buffer.
typedef unsigned long long u64;
struct DuckInfo {
    u64 abi;
    const char *in; u64 in_size;
    char *out; u64 out_limit; u64 out_size;
    char *err; u64 err_limit; u64 err_size;
    const char *ib; u64 ib_limit;
    char *ob; u64 ob_limit; u64 tsc;
} __attribute__((packed));

static const u64 MOD = 1000000007ULL;
static u64 pw(u64 a, u64 b) {
    u64 r = 1 % MOD;
    a %= MOD;
    while (b) { if (b & 1) r = r * a % MOD; a = a * a % MOD; b >>= 1; }
    return r;
}

int main(void) { return 0; }

void __libc_start_main(int (*mf)(int, char **, char **), int ac, char **av) {
    (void)mf;
    struct DuckInfo *d = (struct DuckInfo *)((u64 *)av)[29];
    const char *p = d->in;
    while (*p < '0' || *p > '9') p++;
    u64 n = 0;
    while (*p >= '0' && *p <= '9') n = n * 10 + (u64)(*p++ - '0');
    while (*p < '0' || *p > '9') p++;
    u64 m = 0;
    while (*p >= '0' && *p <= '9') m = m * 10 + (u64)(*p++ - '0');
    if (n > m) { u64 t = n; n = m; m = t; }
    u64 ans;
    if (n == 1) ans = pw(2, m);
    else if (n == 2) ans = 4 * pw(3, m - 1) % MOD;
    else if (n == 3) ans = 112 * pw(3, m - 3) % MOD;
    else {
        // inv2, inv16 and inv3 are the modular inverses of 2, 16 and 3.
        const u64 inv2 = 500000004ULL, inv16 = 562500004ULL, inv3 = 333333336ULL;
        u64 p2n = pw(2, n);
        u64 p4n2 = p2n * p2n % MOD * inv16 % MOD;   // 4^(n-2)
        u64 p4n4 = p4n2 * inv16 % MOD;             // 4^(n-4)
        u64 p2n1 = p2n * inv2 % MOD;               // 2^(n-1)
        u64 ans1 = p4n2 * p2n % MOD;
        u64 ans2 = 5 * p4n4 % MOD * p2n % MOD;
        u64 ans3 = 20 * p2n % MOD * ((p4n4 - 1 + MOD) % MOD) % MOD * inv3 % MOD;
        ans3 = (ans3 + 15 * p2n1) % MOD;
        ans = ((ans1 + ans2) % MOD + ans3) % MOD * 2 % MOD;
        if (n != m) {
            ans = 3 * ((ans - p2n) % MOD + MOD) % MOD;
            ans = ans * pw(3, m - n - 1) % MOD;
        }
    }
    char tmp[24];
    int k = 0;
    do { tmp[k++] = (char)('0' + ans % 10); ans /= 10; } while (ans);
    char *o = d->out;
    while (k) *o++ = tmp[--k];
    *o++ = '\n';
    d->out_size = (u64)(o - d->out);
    __asm__ volatile("mov $60,%%eax; xor %%edi,%%edi; syscall" ::: "rax", "rdi", "memory");
    __builtin_unreachable();
}

评测结果