18.10.4 考试总结

Posted 2021-01-10 rubenisveryhandsome

这道题就是一道肥！肠！裸！的！轮廓线dp 然后因为细节太多了还因为有一个sbsbsb编译错误

就是不准我函数名字取count...我恨 我永远讨厌轮廓线dp

代码

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

const int N = 1e6 + 5;
int dp[2][N],n,m,len[200],cnt[N],ans;
char s[200][40];

void Init( ) {
    
    scanf("%d%d",& n,& m);
    for(int i = 1;i <= n;i ++) {
        scanf("%s", s[i] + 1);
        len[i] = strlen(s[i] + 1);
    }
    for(int i = 0;i < (1 << m);i ++) {
        int w = 0; int j = i;
        while(j) { if(j & 1) w ++; j >>= 1;}
        cnt[i] = w;
    }
}

void Solve( ) {
    
    int now = 0;
    for(int i = 0;i <= m;i ++) s[0][i] = ‘#‘;
    for(int i = 1;i < n * m;i ++) { 
        now ^= 1;
        int row = i / m,col = i % m;
        memset(dp[now ^ 1], 0, sizeof(dp[now ^ 1]));
        for(int sta = 0;sta < (1 << m);sta ++) {
            int high = sta >> (m - col),low = sta ^ (high << (m - col));
            int lnum = cnt[low],hnum = cnt[high],del = 0;
            if(lnum > len[row] || lnum + col < len[row] || hnum > len[row + 1] || hnum + m - col < len[row + 1]) continue;
            if(hnum < len[row + 1]) {
                if((sta & (1 << (m - 1))) && s[row + 1][hnum] == s[row + 1][hnum + 1]) del += 2;
                if((sta & 1) && s[row + 1][hnum + 1] == s[row][len[row] - lnum + 1]) del += 2;
                dp[now ^ 1][(sta >> 1) | (1 << (m - 1))] = max(dp[now ^ 1][(sta >> 1) | (1 << (m - 1))],dp[now][sta] + del);
            }
            dp[now ^ 1][sta >> 1] = max(dp[now ^ 1][sta >> 1], dp[now][sta]);
        }
    }
    for(int i = 0;i < (1 << m);i ++)
        ans = max(ans, dp[now ^ 1][i]);
    printf("%d
",ans);
}

int main( ) {
    
    freopen("group.in","r",stdin);
    freopen("group.out","w",stdout);
    Init( );
    Solve( );
}

这道题挺难的 是一道中国剩余定理的题目

本来的公式还是比较好推出来的 先将终点的坐标变为正数 

考虑要走到终点 向左向右向上向下的步数相互抵消之后 总共是向右边走$n$步 向上走$m$步

那么枚举向左走的步数$x$ 那么向右边就走了$n + x$步 剩下的向下走的步数就是$y = (t - (n + 2 * x) - m) / 2$ 

那么方案数就是

　　　　　　$sum C_{t}^{x}cdot C_{t - x}^{n + x}cdot C_{t - x - x - n}^{y}$

代码

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

const int N = 1e6 + 5;
int dp[2][N],n,m,len[200],cnt[N],ans;
char s[200][40];

void Init( ) {
    
    scanf("%d%d",& n,& m);
    for(int i = 1;i <= n;i ++) {
        scanf("%s", s[i] + 1);
        len[i] = strlen(s[i] + 1);
    }
    for(int i = 0;i < (1 << m);i ++) {
        int w = 0; int j = i;
        while(j) { if(j & 1) w ++; j >>= 1;}
        cnt[i] = w;
    }
}

void Solve( ) {
    
    int now = 0;
    for(int i = 0;i <= m;i ++) s[0][i] = ‘#‘;
    for(int i = 1;i < n * m;i ++) { 
        now ^= 1;
        int row = i / m,col = i % m;
        memset(dp[now ^ 1], 0, sizeof(dp[now ^ 1]));
        for(int sta = 0;sta < (1 << m);sta ++) {
            int high = sta >> (m - col),low = sta ^ (high << (m - col));
            int lnum = cnt[low],hnum = cnt[high],del = 0;
            if(lnum > len[row] || lnum + col < len[row] || hnum > len[row + 1] || hnum + m - col < len[row + 1]) continue;
            if(hnum < len[row + 1]) {
                if((sta & (1 << (m - 1))) && s[row + 1][hnum] == s[row + 1][hnum + 1]) del += 2;
                if((sta & 1) && s[row + 1][hnum + 1] == s[row][len[row] - lnum + 1]) del += 2;
                dp[now ^ 1][(sta >> 1) | (1 << (m - 1))] = max(dp[now ^ 1][(sta >> 1) | (1 << (m - 1))],dp[now][sta] + del);
            }
            dp[now ^ 1][sta >> 1] = max(dp[now ^ 1][sta >> 1], dp[now][sta]);
        }
    }
    for(int i = 0;i < (1 << m);i ++)
        ans = max(ans, dp[now ^ 1][i]);
    printf("%d
",ans);
}

int main( ) {
    
    freopen("group.in","r",stdin);
    freopen("group.out","w",stdout);
    Init( );
    Solve( );
}

这道题就是博弈论了 很容易想到把所有的字符串建成一颗$trie$树  我就直接复制题解了

由于现在获胜目标变为了最后一轮游戏胜利，所以可以有策略地让某一轮输掉或者胜利。

于是现在一个节点的状态变为了四种，由是否拥有选择胜利本轮的能力以及是否拥有选择输掉本轮的能力区分。

对于叶子节点，只有选择输掉的能力。

对于非叶节点，只要有一个子节点不具有选择输掉的能力，该非叶节点便具有选择输掉的能力

只要有一个子节点不具有选择胜利的能力，该非叶节点便具有选择胜利的能力。也就是说，令dp[u] 表示节点u 具有的能力，1 表示具有输掉的能力，2 表示具有胜利的能力，

3 表示两个能力都有，0 则表示两个能力都没有。

那么转移时，dp[u]| = (dp[v]³)，其中v 为u 的子节点。

不妨令1 号点为Trie 树的根节点，那么Pure 胜利一局游戏的条件便是：

根节点处同时具有两种能力（这种情况下，前面$n - 1$ 轮一直输，最后一轮胜利即可） 或者根节点处仅具有胜利的能力并且$K$ 为奇数（这种情况下，两个人只能轮流获得每一轮的胜利）。

剩余情况显然是Dirty 获得胜利，例如根节点处仅具有输掉的能力（Pure 只能一直输，显然

Dirty 胜利），或者根节点处两者能力都不具有（这种情况下，Dirty 具有控制每一轮游戏胜负的能力，显然Dirty 胜利）。

代码

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

const int N = 1e5 + 5;
int son[N][30],dp[N],cnt,tot,head[N],tov[2 * N],nex[2 * N];
int T,K,n;
char s[N];

void insert(char *s, int len) {
    
    int now = 0;
    for(int i = 1;i <= len;i ++) {
        int nd = s[i] - ‘a‘;
        if(! son[now][nd]) son[now][nd] = ++ cnt;
        now = son[now][nd];
    }
}

void add(int u, int v) {
    
    tot ++;
    nex[tot] = head[u];
    tov[tot] = v;
    head[u] = tot;
}

void add_edge( ) {
    
    for(int i = 0;i <= cnt;i ++)
        for(int j = 0;j <= 26;j ++) {
            if(son[i][j]) {add(i, son[i][j]); add(son[i][j], i);}
        }
}

void dfs(int u, int fa) {
    
    bool tag = false;
    for(int i = head[u];i;i = nex[i]) {
        int v = tov[i];
        if(v == fa) continue;
        dfs(v, u); tag = true;
    }
    if(! tag) {
        dp[u] = 1; return ;
    }
    for(int i = head[u];i;i = nex[i]) {
        int v = tov[i]; if(v == fa) continue;
        if((dp[v] & 2) == 0) dp[u] |= 2;
        if((dp[v] & 1) == 0) dp[u] |= 1;
    }
}

void clear( ) {
    
    memset(head, 0, sizeof(head));
    tot = 0; memset(dp, 0, sizeof(dp));
    memset(son, 0, sizeof(son)); cnt = 0;
}

void Solve( ) {
    
    scanf("%d",& T);
    while(T --) {
        clear( );
        scanf("%d%d",& n,& K);
        for(int i = 1;i <= n;i ++) {
            scanf("%s",s + 1);
            insert(s, strlen(s + 1));
        }
        add_edge( );
        dfs(0, 0);
        if(dp[0] == 3) printf("Pure
");
        else if(dp[0] == 0) printf("Dirty
");
        else if(dp[0] == 1) printf("Dirty
");
        else {
            if(K % 2 == 1) printf("Pure
");
            else printf("Dirty
");
        } 
    }
}

int main( ) {
    
    freopen("strGame.in","r",stdin);
    freopen("strGame.out","w",stdout);
    Solve( );
}