[34]（CSP 集训）CSP-S 联训模拟 1

合集 - 赛事(59)

32.[34]（CSP 集训）CSP-S 联训模拟 12024-09-26

A 几何

重复若干次 -> 不能重叠，因此考虑直接暴力 DP

设 $f_{i, j, k}$ 表示主串匹配到第 $i$ 位（将前 $i$ 位分别归为两类），其中 $x$ 在重复了若干次后，又匹配到了第 $j$ 位， $y$ 在重复了若干次后，又匹配到了第 $k$ 位

转移非常好写，枚举 $i$ ，尝试把 $s_{i}$ 分别与 $x_{j}, y_{k}$ 匹配，匹配上了就直接转移到 $f_{i + 1, j + 1, k} (f_{i + 1, j, k + 1})$ ，或者在 $j or k = n$ 的时候直接赋成 $0$

复杂度是 $O (n x y)$ 的，一算 $10^{9}$ ，注意到这个东西完全不挂常数，考虑稍微优化一下

endl 改 \n，代码生下来常数就小的直接过了

否则的话考虑直接 bitset（能 bitset 是因为这题的 dp 数组全是 bool，转移也全是或运算），预处理出 $x, y$ 中能参与 $s_{i}$ 的转移的位置，然后直接 bitset 做就能砍到差不多 $2 \times 10^{8}$

还过不了就是孩子代码一生下来常数就大

解决方案：手写一个用 ull 压

#include<bits/stdc++.h>
using namespace std;
#pragma GCC optimize(3)
#define endl '\n'
int cases;
string s,x,y;
bool f[2][51][51];
// 0:x   1:y
int main(){
    ios::sync_with_stdio(false);
    freopen("geometry.in","r",stdin);
    freopen("geometry.out","w",stdout);
    cin>>cases;
    while(cases--){
        cin>>s>>x>>y;
        f[0][0][0]=1;
        for(int i=1;i<=(int)s.length();++i){
            for(int j=0;j<=(int)x.length();++j){
                for(int k=0;k<=(int)y.length();++k){
                    f[i&1][j][k]&=0;
                }
            }
            for(int j=0;j<=(int)x.length();++j){
                for(int k=0;k<=(int)y.length();++k){
                    if(j!=0 and s[i-1]==x[j-1]){
                        f[i&1][j!=(int)x.length()?j:0][k!=(int)y.length()?k:0]|=f[(i-1)&1][j-1][k!=(int)y.length()?k:0];
                    }
                    if(k!=0 and s[i-1]==y[k-1]){
                        f[i&1][j!=(int)x.length()?j:0][k!=(int)y.length()?k:0]|=f[(i-1)&1][j!=(int)x.length()?j:0][k-1];
                    }
                }
            }
        }
        if(f[((int)s.length())&1][0][0]==true){
            cout<<"Yes"<<endl;
        }
        else{
            cout<<"No"<<endl;
        }
    }
}
/*
abaaabbaab
1112112122

[1 0]
[2 0]
[3 0]

bbaabaabaaabaabaab
221111111121111111

[2,0]
bba
aab
*/

B

我说我的爆搜为什么不对，拉下来对拍拍出一组十字架图

因为我一开始觉得删边等于删点，所以我就每次路过把点删了，但是事实上不是这样，所以这题 $n^{2}$ 的搜完全不可做

因为题目里这么走，相当于走了一个欧拉路，然而欧拉路是要求最多两个节点是奇点，因此考虑转移问题为使原图变为欧拉路

设 $f_{i, 0 / 1, 0 / 1}$ 表示考虑到 $i$ 和它的子树， $i$ 自己是不是奇点， $i$ 和 $i$ 的子树里有没有奇点的最小花费，然后做树形 DP

首先，操作 $A$ 相当于加重边，作用为可以使两边的节点中奇边变成偶边，偶边变成奇边，并且可以对两颗子树进行合并

假如我们把 $j$ 合并到 $i$ 上，合并后 $j$ 就是 $i$ 的子树，，设由 $f_{i, k, l}, f_{j, m, n}$ 转移，那么新的转移方程中的第三项就应该是 $l or m or n$ ，即 $i$ 和 $j$ 只要有一个的子树存在奇点，那么合并后 $i$ 的子树就存在奇点

接下来看 $B$ 操作，考虑 $B$ 的贡献变化量，有一结论使得 $B$ 操作变化量与奇点数量变化量正相关，即 $⌊$ 奇点数量除二 $⌋$ 减一 $= B$ 操作数量，不会证不放了

如果我们执行 $B$ 操作的两个点都是奇点，那么直接瞬移，这两个点之间就不需要连边了，可以看成两个奇点都变成了偶点，所以 $B$ 操作总数减一

如果两个点全是偶点，本来能自己过去，非要瞬移到另一边，现在过不去了，还要再瞬移回来，所以会让 $B$ 操作加一

否则，实际上瞬移一下没啥变化， $B$ 不变

统计答案的时候，原图可以是欧拉回路，或者可以存在两个奇点（此时需要一次瞬移），注意这个奇点不一定非要有一个在根节点上

#include<bits/stdc++.h>
using namespace std;
#define int long long
int n,a,b;
vector<int>e[500001];
const int inf=LLONG_MAX/10;
int f[500001][2][2],g[2][2];
void dfs(int now,int last){
    f[now][0][0]=0;
    f[now][0][1]=inf;
    f[now][1][0]=inf;
    f[now][1][1]=inf;
    for(int i:e[now]){
        if(i!=last){
            dfs(i,now);
            for(int j=0;j<=1;++j){
                for(int k=0;k<=1;++k){
                    g[j][k]=f[now][j][k];
                    f[now][j][k]=inf;
                }
            }
            for(int j=0;j<=1;++j){
                for(int k=0;k<=1;++k){
                    for(int l=0;l<=1;++l){
                        for(int m=0;m<=1;++m){
                            f[now][j][k|l|m]=min(f[now][j][k|l|m],g[j][k]+f[i][l][m]+a);
                            int cost=0;
                            if(!j and !l) cost=b;
                            else if(j and l) cost=-b;
                            f[now][1-j][k|(1-l)|m]=min(f[now][1-j][k|(1-l)|m],g[j][k]+f[i][l][m]+cost);
                        }
                    }
                }
            }
        }
    }
}
signed main(){
    freopen("analyse.in","r",stdin);
    freopen("analyse.out","w",stdout);
    cin>>n>>a>>b;
    for(int i=1;i<=n-1;++i){
        int x,y;cin>>x>>y;
        e[x].push_back(y);
        e[y].push_back(x);
    }
    dfs(1,0);
    cout<<min({f[1][0][0],f[1][1][1]-b,f[1][0][1]-b});
}

D 组合

神秘题，但是我觉得这个思路还是很好的

首先因为不会对你的询问返回答案，也就意味着没办法用类似二分的方法求解，否则会被卡成完全二叉树

题目让我们构造 $m$ 个 $N$ 位二进制数，考虑转化成 $N$ 个 $m$ 位二进制数，每次询问相当于询问一竖列

只考虑其中的三组二进制数，发现这三组有贡献的条件是两两位或结果不同，证明：设 $a or b = a or c$ ，对于竖列的询问，若 $a_{i} or b_{i} = a_{i} or c_{i} = 1$ ，则对于任何一组询问都返回 $1$ ，若 $a_{i} or b_{i} = a_{i} or c_{i} = 0$ ，则对于任何一组询问都返回 $0$ ，没有区分的意义，所以要求全部二进制数两两位或运算不同

然后就到了神秘的地方，怎么构造这 $N$ 个二进制数

STD 的做法是枚举 $8$ 位和 $9$ 位的二进制数（这里指的是二进制数中 $1$ 的个数），暴力判断能不能放进去，能放就放

这个 $8$ 和 $9$ 太神秘了，不知道他咋出的，在 $N = 1000$ 的时候正好能卡到 $m = 26$ ，我改了参之后再跑，发现从 $4$ 位开始跑贼慢，跑了三个小时才七百多个，从 $15$ 位开始跑就莫名其妙寄了，好像是跑不出来答案卡死循环了

好在结论题比较好改

ADD: 其实这个 STD 挺好写的，__builtin_popcount() 是用来数二进制数里 $1$ 的个数的，然后你开两个 vector 去存，每次都尝试从里面拿出一个塞到已有的数后面，不合法就扔掉，合法的判断直接扫一遍就行

STD

#include<bits/stdc++.h>
using namespace std;
int N = 20;
int a[1015];
bitset<1073741824> bk;
int main() {
    int cur = 0;
    vector<int> vec;
    for (int i = 0; i < (1 << N); i++) {
        if (__builtin_popcount(i) == 8)
            vec.push_back(i);
    }
    for (int i = 0; i < (1 << N); i++) {
        if (__builtin_popcount(i) == 9)
            vec.push_back(i);
    }
    for (int i = 1; i <= 1010; i++) {
        bool fl2 = 0;
        for (auto t : vec) {
            a[i] = t;
            bool fl = 0;
            for (int j = 1; j <= i; j++) {
                if (bk[a[i] | a[j]] || (i != j && i <= 996 && __builtin_popcount(a[i] | a[j]) < 11)) {
                    fl = 1;
                    for (int k = 1; k < j; k++)
                        bk[a[i] | a[k]] = 0;
                    break;
                }
                bk[a[i] | a[j]] = 1;
            }
            if (fl)
                continue;
            fl2 = 1;
            break;
        }
        if (!fl2) {
            N++;
            vec.clear();
            for (int j = 0; j < (1 << N); j++) {
                if (__builtin_popcount(j) == 8)
                    vec.push_back(j);
            }
            if (N >= 24) {
                for (int j = 0; j < (1 << N); j++) {
                    if (__builtin_popcount(j) == 9)
                        vec.push_back(j);
                }
            }
            if (N == 26) {
                for (int j = 0; j < (1 << N); j++) {
                    if (__builtin_popcount(j) != 8 && __builtin_popcount(j) != 9)
                        vec.push_back(j);
                }
            }
            i--;
            continue;
        }
        cout << i << ' ' << N << endl;
        if (N > 26) {
            cur = i - 1;
            break;
        }
    }
    freopen("output.txt", "w", stdout);
    for (int i = 1; i <= 1000; i++)
        cout << a[i] << ',';
    cout << endl;
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
int a[]; //自己去跑 STD
string to_binary(int x){
    string ans;
    while(x){
        if(x&1) ans.push_back('1');
        else ans.push_back('0');
        x>>=1;
    }
    // cout<<"::"<<ans<<endl;
    while(ans.size()<26) ans.push_back('0');
    reverse(ans.begin(),ans.end());
    return ans;
}
vector<string>ans(27);
int main(){
    ofstream cth("combination.out");
    for(int i=0;i<=999;++i){
        string as=to_binary(a[i]);
        // cout<<as<<endl;
        for(int j=0;j<=25;++j){
            ans[j].push_back(as[j]);
        }
    }
    cth<<26<<endl;
    for(int i=0;i<=25;++i){
        cth<<ans[i]<<endl;
    }
}