【10.4校内测试】【轮廓线DP】【中国剩余定理】【Trie树+博弈】

考场上几乎是一看就看出来轮廓线叻...可是调了两个小时打死也过不了手出样例！std发下来一对，特判对的啊，转移对的啊，$dp$数组竟然没有取max！！！

某位考生当场死亡。

结果下午又请了诸位dalao来看为什么剩下wa两个点！结果数组开小。

某位考生再次死亡。

#include<bits/stdc++.h>
#define RG register
using namespace std;

int dp[][(<<)+], cnt[(<<)+];
int R, C, a[][];////////不开够影响很大！！

int count(int sta) {
    int num = ;
    while(sta) {
        if(sta & )    num ++;
        sta >>= ;
    }
    return num;
}

void init() {
    scanf("\n");
    for(int i = ; i <= R; i ++) {
        char s;    int cnt = ;
        s = getchar();
        while(s != '\n') {
            a[i][++a[i][]] = s - 'A' + ;
            s = getchar();
        }
    }
    for(int i = ; i < ( << C); i ++)
        cnt[i] = count(i);
}

struct Node {
    int n1, n2;
    Node(int n1 = , int n2 = ) :
        n1(n1), n2(n2) { }
};

inline Node check(int sta, int pos, int line) {
    int s1 = sta >> (pos - ), s2 = sta & (( << (pos - )) - );
    int num1 = cnt[s1], num2 = cnt[s2];
    if(num1 > a[line-][] || num2 > a[line][] || num2 + C - pos +  < a[line][] || num1 + pos -  < a[line-][])    return Node(-, -);
    return Node(num1, num2);
}

int main() {
    freopen("group.in", "r", stdin);
    freopen("group.out", "w", stdout);
    scanf("%d%d", &R, &C);
    init();
    int now = ;
    for(RG int i = ; i <= R; i ++) {
        for(RG int j = ; j <= C; j ++) {
            now ^= ;
            memset(dp[now], , sizeof(dp[now]));
            for(RG int s = ; s < ( << C); s ++) {
                int pre = s & ( << (C - )); int las = s & ;
                Node opt = check(s, j, i);
                if(opt.n1 == -)    continue;
                int q = opt.n1, p = opt.n2;
                int num1, num2;
                if(!pre)    num1 = ;
                else num1 = a[i-][a[i-][]-q+];
                if(!las || j == )     num2 = ;
                else num2 = a[i][p];
                if(p +  <= a[i][]) {
                    int ss = (s ^ pre) <<  | ;
                    int t = dp[now ^ ][s];
                    if(a[i][p+] == num1 && pre)    t += ;
                    if(a[i][p+] == num2 && las)    t += ;
                    dp[now][ss] = max(t, dp[now][ss]);////我暴毙
                }
                int ss = (s ^ pre) << ;
                dp[now][ss] = max(dp[now][ss], dp[now ^ ][s]);
            }
        }
    }
    int ans = ;
    for(int s = ; s < ( << C); s ++) {
        if(cnt[s] != a[R][])    continue;
        ans = max(ans, dp[now][s]);
    }
    printf("%d", ans);
    return ;
} 

我们可以发现在模数为质数时，可以直接用组合+求逆元计算出来，但是求逆元只能是在模数与要求逆元数互质时才行。

又因为题目明显暗示$MOD$由质数组成，所以直接套中国剩余定理即可。需要注意的是，对于每个分解出来的质因子都要重新求对应的逆元和阶乘。

#include<bits/stdc++.h>
#define LL long long
using namespace std;

int n, m, T, MOD;
LL fac[], va[], vm[], inv[];
LL isnot[], prime[], t;

void div() {
    isnot[] = ;
    for(int i = ; i <= ; i ++) {
        if(!isnot[i])
            prime[++t] = i;
        for(int j = ; j <= t; j ++) {
            int to = prime[j] * i;
            if(to > )    break;
            isnot[to] = ;
            if(i % prime[j] == )    break;
        }
    }
}

LL tot;
void init() {
    div();
    LL tmp = MOD;
    for(LL i = ; i * i <= tmp && tmp != ; i ++)
        if(tmp % i == )    vm[++tot] = i, tmp /= i;
    if(tmp > )    vm[++tot] = tmp;
}

LL mpow(LL a, LL b, LL mod) {
    LL ans = ;
    for(; b; b >>= , a = a * a % mod)
        if(b & )    ans = ans * a % mod;
    return ans;
}

LL rev(LL a, LL mod) {
    return mpow(a, mod - , mod);
}

LL C(LL q, LL p, LL mod) {
    if(p > q)    return ;
    return fac[q] * inv[p] % mod * inv[q-p] % mod;
}

LL Lucas(LL x, LL y, LL mod) {
    if(x < y)    return ;
    if(y == )    return ;
    return Lucas(x / mod, y / mod, mod) * C(x % mod, y % mod, mod) % mod;
}

LL Chinese_remainder_theorem() {
    LL ans = ;
    for(LL i = ; i <= tot; i ++) {
        LL mi = MOD / vm[i];
        LL rei = rev(mi, vm[i]);
        ans = (ans + mi * rei % MOD * va[i] % MOD) % MOD;
    }
    return ans;
}

int main() {
    freopen("visit.in", "r", stdin);
    freopen("visit.out", "w", stdout);
    scanf("%d%d", &T, &MOD);
    scanf("%d%d", &n, &m);
    if(n < )    n = -n;
    if(m < )    m = -m;
    int c = (T - n - m) / ;
    if(T < n + m || (n + m - T) %  == ) {
        printf("0\n"); return ;
    }
    init();
    for(LL k = ; k <= tot; k ++) {
        fac[] = ;
        for(long long i = ;i <= T;i ++)
        fac[i] = 1ll * fac[i-] * i % vm[k];
        inv[] = inv[] = ;
        for(long long i = ;i <= T;i ++)
        inv[i] = 1ll * inv[vm[k] % i] * (vm[k] - vm[k] / i) % vm[k];
        for(long long i = ;i <= T;i ++)
        inv[i] = 1ll * inv[i] * inv[i - ] % MOD;
        for(LL i = ; i <= c; i ++) {
            LL j = c - i;
            va[k] = (va[k] + 1ll * Lucas(T, i, vm[k]) * Lucas(T-i, j, vm[k]) % vm[k] * 1ll * Lucas(T-i-j, i+n, vm[k]) % MOD) % MOD;
        }
    }
    LL ans = Chinese_remainder_theorem();
    printf("%lld", ans);
    return ;
}

由字符串的前缀和想到建$Trie$树。我们发现，对于$Trie$树上某一节点，如果它的儿子有一个是可以选择必胜，那么当前节点就可以选择必败；如果它的儿子有一个是可以选择必败，那么当前节点就可以选择必胜；如果它的儿子全都可胜可败，那么它就没有选择权利；如果它的儿子有一个没有选择权利，那么它就可胜可败。在$Trie$树上直接深搜处理出每个节点的状态。

出来后如果根节点可胜可败，那么$Pure$就可以选择前面所有局都输，最后胜，因此她必胜；如果根节点必败，那么$Dirty$必胜；如果根节点必胜，那么要看局数$k$的奇偶性；如果根节点无法选择，也是$Dirty$必胜。

#include<bits/stdc++.h>
using namespace std;

int n, k;
int son[][], tail;
char str[];

void add(char *s) {
    int nd = ;    int len = strlen(s);
    for(int i = ; i < len; i ++) {
        int t = s[i] - 'a';
        if(!son[nd][t])    son[nd][t] = ++ tail;
        nd = son[nd][t];
    }
}

int dp[];
int Dfs(int u) {
    int fl = -, sum = , num = ;
    for(int i = ; i < ; i ++) {
        if(son[u][i]) {
            sum ++;
            fl = Dfs(son[u][i]);
            if(fl == )    dp[u] |= ;
            if(fl == )    dp[u] |= ;
            if(fl == )    dp[u] |= ;
            if(fl == )    num ++;
        }
    }
    if(num == sum)    dp[u] = ;
    if(fl == -)    dp[u] = ;
    return dp[u];
}

int main() {
    freopen("strGame.in", "r", stdin);
    freopen("strGame.out", "w", stdout);
    int T;
    scanf("%d", &T);
    while(T --) {
        memset(son, , sizeof(son));
        memset(dp, , sizeof(dp));
        tail = ;
        scanf("%d%d", &n, &k);
        for(int i = ; i <= n; i ++) {
            scanf("%s", str);
            add(str);
        }
        Dfs();
        if(dp[] == )    printf("Pure\n");
        else if(dp[] == ) {
            printf("Dirty\n");
        } else if(dp[] == ) {
            if(k % )    printf("Pure\n");
            else    printf("Dirty\n");
        } else printf("Dirty\n");
    }
    return ;
}