[LOJ#2327]「清华集训 2017」福若格斯

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
#include <string>
#include <map>
using namespace std;
#define rep(i, s, t) for(int i = (s); i <= (t); i++)
#define dwn(i, s, t) for(int i = (s); i >= (t); i--)

int read() {
    int x = 0, f = 1; char c = getchar();
    while(!isdigit(c)){ if(c == ‘-‘) f = -1; c = getchar(); }
    while(isdigit(c)){ x = x * 10 + c - ‘0‘; c = getchar(); }
    return x * f;
}

#define maxn 25
#define maxm 2000010
#define MOD 998244353
#define oo 2147483647
#define LL long long

map <string, int> val;
map <int, int> tot;

int search(string s) {
    if(val.count(s)) return val[s];
    int L = oo, R = oo;
    rep(i, 0, 4) {
        string to;
        if(s[i] == ‘L‘) {
            to = s;
            if(i <= 3 && to[i+1] == ‘_‘) swap(to[i], to[i+1]), L = search(to);
            to = s;
            if(i <= 2 && to[i+1] == ‘R‘ && to[i+2] == ‘_‘) swap(to[i], to[i+2]), L = search(to);
        }
        if(s[i] == ‘R‘) {
            to = s;
            if(i >= 1 && to[i-1] == ‘_‘) swap(to[i], to[i-1]), R = search(to);
            to = s;
            if(i >= 2 && to[i-1] == ‘L‘ && to[i-2] == ‘_‘) swap(to[i], to[i-2]), R = search(to);
        }
    }
    int now = 0;
    if(L == 0 && R == oo) now = 2;
    if(L == oo && R == 0) now = -2;
    if(L == 0 && R == 2) now = 1;
    if(L == -2 && R == 0) now = -1;
    // 3 up, -3 down, 4 star.
    if(L == 0 && R == 4) now = 3;
    if(L == 4 && R == 0) now = -3;
    if((L == R && R == 0) || (L == 3 && R == -3)) now = 4;
    // These are the states that can be found in the solution.(See the state-tree)
    return val[s] = now;
}

char str[maxn];

int Pow(int a, int b) {
    int ans = 1, t = a;
    while(b) {
        if(b & 1) ans = (LL)ans * t % MOD;
        t = (LL)t * t % MOD; b >>= 1;
    }
    return ans;
}

int fac[maxm], inv[maxm];
LL C(int n, int m) { return (LL)fac[n] * inv[m] % MOD * inv[n-m] % MOD; }

LL t_1, t0, t1, A[maxm];
void Creal(int s_2, int s_1, int s1, int s2) {
    t_1 = t0 = t1 = 0;
    rep(i, 0, s_1 + s1) A[i] = C(s_1 + s1, i);
    rep(i, 1, s_1 + s1) (A[i] += A[i-1]) %= MOD;
    rep(i, 0, s_2 + s2) {
        int k = (i - s_2 << 1);
        LL now = C(s_2 + s2, i);
        if(k < -s1) t_1 += now * A[s_1+s1] % MOD; // all negative
        else if(k > s_1) t1 += now * A[s_1+s1] % MOD; // all positive
        else {
            t0 += now * (A[s_1-k] - (s_1 - k == 0 ? 0 : A[s_1-k-1]) + MOD) % MOD;
            t_1 += now * (s_1 - k == 0 ? 0 : A[s_1-k-1]) % MOD;
            t1 += now * (A[s_1+s1] - A[s_1-k] + MOD) % MOD;
        }
    }
    t_1 %= MOD; t0 %= MOD; t1 %= MOD;
    return ;
}
LL f_2, f_1, f0, f1, f2;
void Cfake(int s_1, int s1) {
    f_2 = f_1 = f0 = f1 = f2 = 0;
    rep(i, 0, s_1 + s1) {
        LL now = C(s_1 + s1, i);
        if(i < s_1 - 1) f_2 += now;
        if(i == s_1 - 1) f_1 += now;
        if(i == s_1) f0 += now;
        if(i == s_1 + 1) f1 += now;
        if(i > s_1 + 1) f2 += now;
    }
    f_2 %= MOD; f_1 %= MOD; f0 %= MOD; f1 %= MOD; f2 %= MOD;
    return ;
}

int main() {
    search(string("LL_RR"));
    
    fac[0] = inv[0] = 1;
    rep(i, 1, maxm - 1) fac[i] = (LL)fac[i-1] * i % MOD, inv[i] = (LL)inv[i-1] * Pow(i, MOD - 2) % MOD;
    
    read(); int T = read();
    while(T--) {
        int n = read();
        rep(i, -3, 4) tot[i] = 0;
        rep(i, 1, n) scanf("%s", str), tot[val[string(str)]] += read();
        Creal(tot[-2], tot[-1], tot[1], tot[2]);
        Cfake(tot[-3], tot[3]);
        /*
        s0 and s1 are used to separate the imaginary(fake) part.
        s0: number of star is even
        s1: number of star is odd
        Only when star doesn‘t exist(or appears even number of times)
            situation abs(Up - Down) = 1 can be count in "L wins" or "R wins".
        */
        LL s0 = 1, s1 = 0, Lw = 0, Rw = 0, Fw = 0, Fl = 0;
        if(tot[4]) s0 = s1 = Pow(2, tot[4] - 1);
        // Real part determims who will win.
        Lw += t1 * Pow(2, tot[-3] + tot[4] + tot[3]) % MOD;
        Rw += t_1 * Pow(2, tot[-3] + tot[4] + tot[3]) % MOD;
        // When Real part is equal(total sum is 0)
        Lw += t0 * s0 % MOD * (f1 + f2) % MOD; // Up more, then L wins.
        Rw += t0 * s0 % MOD * (f_1 + f_2) % MOD; // Down more, then R wins.
        Fl += t0 * s0 % MOD * f0 % MOD; // First lose.(state 0, this state includes (or equally) nothing)
        Lw += t0 * s1 % MOD * f2 % MOD; // (Up - Down) more than one, then L wins.
        Rw += t0 * s1 % MOD * f_2 % MOD; // (Down - Up) more than one, then R wins.
        Fw += t0 * s1 % MOD * (f1 + f_1 + f0) % MOD; // First win.
        Lw %= MOD; Rw %= MOD; Fw %= MOD; Fl %= MOD;
        // At last, everybody multiply state 0 because we ignored it before.
        (Lw *= Pow(2, tot[0])) %= MOD;
        (Rw *= Pow(2, tot[0])) %= MOD;
        (Fw *= Pow(2, tot[0])) %= MOD;
        (Fl *= Pow(2, tot[0])) %= MOD;
        printf("%lld %lld %lld %lld\n", Lw, Rw, Fw, Fl);
    }
    
    return 0;
}