CSP2019

$CSP\space S$

格雷码

$solution:$

直接模拟即可。

时间复杂度 $O(n)$ 。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
void solve(unsigned long long N,unsigned long long K){
    if(N==) return;
    unsigned long long p=(1ull<<(N-1ull));
    if(p>=K){printf("");solve(N-,K);return;}
    printf("");solve(N-,2ull*p-K+1ull);return;
}
unsigned long long n,k;
signed main(){
    cin>>n>>k;
    if(n==64ull&&k==18446744073709551615ull){
        printf("");
        for(int i=;i<=;i++) printf("");printf("\n");
        return ;
    }
    k++;
    solve(n,k);printf("\n");return ;
}

括号树

$solution:$

考虑从 $1$ 号点到 $u$ 号点的括号序列中有多少个后缀是括号序列的，这个可以通过栈做简单的 $dp$ 得到。

时间复杂度 $O(n)$ 。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<vector>
#define int long long
using namespace std;
inline int read(){
    int f=,ans=;char c=getchar();
    while(c<''||c>''){if(c=='-')f=-;c=getchar();}
    while(c>=''&&c<=''){ans=ans*+c-'';c=getchar();}
    return f*ans;
}
const int MAXN=;
int fa[MAXN],N;
vector<int> vec[MAXN];
char str[MAXN];int sta[MAXN],top,f[MAXN],A;
void dfs(int u,int Ans){
    int del=;bool ins=;
    if(str[u]=='(') ins=,sta[++top]=u;
    else if(str[u]==')'&&top){int i=sta[top];del=i;f[u]=f[fa[i]]+;top--;Ans+=f[u];}
    A^=(u*Ans);for(int i=;i<vec[u].size();i++) dfs(vec[u][i],Ans);
    if(del) sta[++top]=del;if(ins) top--;
    return;
}
signed main(){
    N=read();scanf("%s",str+);
    for(int i=;i<=N;i++) vec[(fa[i]=read())].push_back(i);
    dfs(,);
    printf("%lld\n",A);return ;
}/*
5
)()()
1 1 2 1
*/

Emiya 家今天的饭

$solution:$

考虑 $O(n^3m)$ $dp$ 的优化，因为此 $dp$ 的状态 $f_{i,j,k,p}$ 表示当前考虑第 $i$ 列的容斥，其中在前 $j$ 行中选择 $k$ 个为第 $i$ 列，$p$ 个不为第 $i$ 列，因为状态数位 $O(n^3m)$ 转移 $O(1) $ ，所以总时间复杂度为 $O(n^3m)$ 。

而我们发现若 $k-p\geq 0$ 即可以在容斥时减去，所以设 $g_{i,j,k}$ 表示当前考虑第 $i$ 列的容斥，其中在前 $j$ 行选择第 $i$ 列的减去选择但没有选择第 $i$ 列的等于 $k$ 个，因为转移 $O(1)$ 所以时间为 $O(n^2m)$ 。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#define mod 998244353
#define int long long
using namespace std;
inline int read(){
    int f=,ans=;char c=getchar();
    while(c<''||c>''){if(c=='-')f=-;c=getchar();}
    while(c>=''&&c<=''){ans=ans*+c-'';c=getchar();}
    return f*ans;
}
const int MAXN=;
const int MAXM=;
int N,M,f[MAXN][MAXN],g[MAXN][MAXN<<],S[MAXN],A[MAXN][MAXM],Ans;
int Mod(int x){return ((x%mod)+mod)%mod;}
signed main(){
    N=read(),M=read();
    for(int i=;i<=N;i++){
        for(int j=;j<=M;j++) S[i]+=(A[i][j]=read()),S[i]%=mod;
    }
    f[][]=;
    for(int i=;i<=N;i++){
        for(int j=;j<=N;j++){
            f[i][j]=f[i-][j];
            if(j) f[i][j]+=f[i-][j-]*S[i];f[i][j]%=mod;
            if(i==N&&j) Ans+=f[i][j],Ans%=mod;
        }
    }
    for(int i=;i<=M;i++){
        memset(g,,sizeof(g));
        g[][N]=;
        for(int j=;j<=N;j++){
            for(int k=;k<=*N;k++){
                g[j][k]=g[j-][k]+g[j-][k+]*Mod(S[j]-A[j][i]);
                if(k) g[j][k]+=g[j-][k-]*A[j][i];
                g[j][k]%=mod;
            }
        }
        for(int j=;j<=N;j++) Ans-=g[N][N+j],Ans=Mod(Ans);
    }printf("%lld\n",Ans);return ;
}

划分

$solution:$

考虑 $O(n^3)$ 的暴力 $dp$ ，设 $f_{i,j}$ 表示最后一段为 $[i,j]$ 的最小代价，通过打表可以发现 $f_{i,j}\leq f_{i,j-1}$ 。

所以说问题就转换成了求 $f$ 有解的最大右端点，只维护 $f$ 中的转移点即可，不需要管 $f$ 的具体值，在最后计算答案即可。

设 $F_i$ 表示 $f_{i}$ 的最右转移点，即 $(F_i,i]$ 为若 $f$ 值最小区间，则 $F_i=max\{j\}\space(S_i-S_j\geq S_j-S_{F_j})$ ，即 $S_i\geq 2\times S_j-S_{F_j}$ 。

直接单调队列优化即可，而最后可以用 $int128$ 或手写高精度。时间复杂度 $O(n)$ 。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#define LL long long
using namespace std;
inline int read(){
    int f=,ans=;char c=getchar();
    while(c<''||c>''){if(c=='-')f=-;c=getchar();}
    while(c>=''&&c<=''){ans=ans*+c-'';c=getchar();}
    return f*ans;
}
const int MAXN=;
int N,A[MAXN],opt,B[MAXN],P[MAXN],L[MAXN],R[MAXN],u;
void Maker(){
    if(!opt){for(int i=;i<=N;i++) A[i]=read();return;}
    int pw=;for(int i=;i<=;i++) pw*=;
    int x=read(),y=read(),z=read();B[]=read(),B[]=read();int m=read();
    for(int i=;i<=N;i++) B[i]=(LL)((LL)x*B[i-]+(LL)y*B[i-]+(LL)z)%pw;
    for(int i=;i<=m;i++) P[i]=read(),L[i]=read(),R[i]=read();
    int ps=;
    for(int i=;i<=N;i++){
        if(!(P[ps-]<i&&i<=P[ps])) ps++;
        A[i]=B[i]%(R[ps]-L[ps]+)+L[ps];
    }return;
}
int f[MAXN],head=,tail=,Que[MAXN];
LL S[MAXN];
LL calc(int id){return 2ll*S[id]-S[f[id]];}
void write(__int128 u){if(!u) return;write(u/);putchar((u%)+'');return;}
int main(){
    N=read();opt=read();Maker();
    for(int i=;i<=N;i++) S[i]=S[i-]+(LL)A[i];
    for(int i=;i<=N;i++){
        while(head<tail&&calc(Que[head+])<=S[i]) head++;f[i]=Que[head];
        while(head<tail&&calc(Que[tail])>=calc(i)) tail--;Que[++tail]=i;
    }
    __int128 Ans=;u=N;
    while(u){
        Ans+=(__int128)(S[u]-S[f[u]])*(__int128)(S[u]-S[f[u]]);
        u=f[u];
    }
    write(Ans);printf("\n");
    return ;
}

树的重心

$solution:$

考虑 $u$ 号点的贡献，设 $f_u$ 表示以 $u$ 为根子树下子树最大的。

考虑如何再删掉 $(x,fa_x)$ 这条边时重心为 $u$ 。

若 $x$ 为 $u$ 的祖先，则
$$
\begin{equation}
\left\{
\begin{array}{**lr**}
f_u\leq \lfloor\dfrac{siz_x}{2}\rfloor\\
siz_x-siz_u\leq \lfloor\dfrac{siz_x}{2}\rfloor
\end{array}
\right.
\end{equation}
$$
即 $2\cdot f_u\leq siz_x\leq 2\cdot siz_u$ 。

若 $x$ 在 $u$ 的子树下，可得 $2\cdot siz_v-N\leq siz_x\leq \min\{N-2\cdot f_u,2\cdot siz_u-N\}$ 。而 $f_u$ 表示除了 $v$ 以外最大子树。

其余情况则 $N-2\cdot siz_u\leq siz_x\leq N-2\cdot f_u$ 。

对于祖先情况可以直接在 $dfs$ 遍历是用树状数组维护，子树可以 $dfs$ 序后树状数组维护，其余情况可以通过整体减去祖先与子树得到。

时间复杂度 $O(n\log n)$ 。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<vector>
#define LL long long
using namespace std;
inline int read(){
    int f=,ans=;char c=getchar();
    while(c<''||c>''){if(c=='-')f=-;c=getchar();}
    while(c>=''&&c<=''){ans=ans*+c-'';c=getchar();}
    return f*ans;
}
const int MAXN=;
struct node{
    int u,v,nex;
}x[MAXN<<];
int T,N,head[MAXN],cnt,dfn[MAXN],rev[MAXN],tot,fa[MAXN],f1[MAXN],f2[MAXN],siz[MAXN];
inline void add(int u,int v){
    x[cnt].u=u,x[cnt].v=v,x[cnt].nex=head[u],head[u]=cnt++;
}
inline void dfs(int u,int fath){
    siz[u]=;fa[u]=fath;dfn[u]=++tot,rev[tot]=u;
    for(register int i=head[u];i!=-;i=x[i].nex){
        if(x[i].v==fath) continue;
        dfs(x[i].v,u);
        siz[u]+=siz[x[i].v];int res=siz[x[i].v];
        if(res>=f1[u]) f2[u]=f1[u],f1[u]=res;
        else if(res>=f2[u]) f2[u]=res;
    }return;
}
int Num[][MAXN];
struct BIT{
    int Ans[MAXN];
    void clear(){memset(Ans,,sizeof(Ans));}
    int lowbit(int x){return x&-x;}
    void Modify(int x,int w){for(;x<=N;x+=lowbit(x)) Ans[x]+=w;return;}
    int Query(int x){if(x==-) return ;int res=;for(;x;x-=lowbit(x)) res+=Ans[x];return res;}
    void ins(int x,int w){Modify(x,w);return;}
    int Que(int l,int r){if(l>r) return ;return Query(r)-Query(l-);}
}bit;
struct Node{
    int opt1,opt2,l,r,U;
};
vector<Node> vec[MAXN];
inline void dfs1(int u,int fath){
    if(u!=) bit.ins(siz[u],);
    for(register int i=;i<vec[u].size();++i){
        Num[vec[u][i].opt1][u]+=vec[u][i].opt2*bit.Que(vec[u][i].l,vec[u][i].r);
        if(vec[u][i].opt1==){
            int L=vec[u][i].l,R=vec[u][i].r;
            Num[vec[u][i].opt1][u]+=vec[u][i].opt2*((L<=siz[])&&(siz[]<=R));
        }
    }
    for(register int i=head[u];i!=-;i=x[i].nex){
        if(x[i].v==fath) continue;
        dfs1(x[i].v,u);
    }
    if(u!=) bit.ins(siz[u],-);
    return;
}
signed main(){
    T=read();
    while(T--){
        tot=;cnt=;
        memset(Num,,sizeof(Num));
        memset(head,-,sizeof(head));memset(f1,,sizeof(f1));memset(f2,,sizeof(f2));
        N=read();
        for(register int i=;i<N;++i){int u=read(),v=read();add(u,v),add(v,u);}dfs(,);
        for(register int i=;i<=N;++i) vec[i].clear();bit.clear();
        for(register int i=;i<=N;++i){
            Node e;e.opt1=,e.opt2=,e.l=*f1[i],e.r=*siz[i];
            e.l=max(e.l,),e.r=min(e.r,N);
            vec[i].push_back(e);
            int L=N-*siz[i],R=N-*f1[i];L=max(L,),R=min(R,N);
            e.opt1=,e.opt2=-,e.l=L,e.r=R;
            vec[i].push_back(e);
        }dfs1(,);

        bit.clear();for(int i=;i<=N;i++) vec[i].clear();
        for(register int xx=;xx<=N;++xx){
            for(register int i=head[xx];i!=-;i=x[i].nex){
                if(x[i].v==fa[xx]) continue;
                Node e;int EE=;
                if(f1[xx]==siz[x[i].v]) EE=f2[xx];
                else EE=f1[xx];
                e.opt1=,e.opt2=,e.l=*siz[x[i].v]-N,e.r=min(N-*EE,*siz[xx]-N);e.l=max(e.l,),e.r=min(e.r,N);e.U=xx;
                vec[dfn[x[i].v]+siz[x[i].v]-].push_back(e);
                e.opt2=-;
                vec[dfn[x[i].v]-].push_back(e);
            }
            int L=N-*siz[xx],R=N-*f1[xx];L=max(L,),R=min(R,N);
            Node e;e.opt1=,e.opt2=-,e.l=L,e.r=R;e.U=xx;
            vec[dfn[xx]+siz[xx]-].push_back(e);
            e.opt2=;vec[dfn[xx]].push_back(e);
        }
        for(register int i=;i<=N;++i){
            bit.ins(siz[rev[i]],);
            for(register int j=;j<vec[i].size();++j){
                Node e;e=vec[i][j];
                Num[e.opt1][e.U]+=e.opt2*bit.Que(e.l,e.r);
            }
        }
        for(register int i=;i<=N;++i){int L=N-*siz[i],R=N-*f1[i];L=max(L,),R=min(R,N);Num[][i]+=bit.Que(L,R);}
        LL Ans=;
        for(register int i=;i<=N;++i) Ans+=(LL)i*(LL)(Num[][i]+Num[][i]+Num[][i]);
        printf("%lld\n",Ans);
    }
}

$CSP\space J$

数字游戏

$solution:$

直接模拟。时间复杂度 $O(1)$ 。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
inline int read(){
    int f=,ans=;char c=getchar();
    while(c<''||c>''){if(c=='-')f=-;c=getchar();}
    while(c>=''&&c<=''){ans=ans*+c-'';c=getchar();}
    return f*ans;
}
const int MAXN=;
char str[MAXN];
int main(){
//    freopen("number.in","r",stdin);
//    freopen("number.out","w",stdout);
    scanf("%s",str+);int len=strlen(str+),Ans=;
    for(int i=;i<=len;i++) Ans+=(str[i]=='');
    printf("%d\n",Ans);return ;
}

公交换乘

$solution:$

线段树二分模板题。时间复杂度 $O(n\log n)$ 。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#define int long long
using namespace std;
inline int read(){
    int f=,ans=;char c=getchar();
    while(c<''||c>''){if(c=='-')f=-;c=getchar();}
    while(c>=''&&c<=''){ans=ans*+c-'';c=getchar();}
    return f*ans;
}
const int MAXN=;
struct node{
    int w,t;
}g[MAXN];
int N,tot,Ans;
struct Segment_Tree{
    int Maxn[MAXN<<];
    void Modify(int k,int l,int r,int x,int y,int w){
        if(x<=l&&r<=y) {Maxn[k]=w;return;}
        int mid=l+r>>;
        if(x<=mid) Modify(k<<,l,mid,x,y,w);
        if(mid<y) Modify(k<<|,mid+,r,x,y,w);
        Maxn[k]=max(Maxn[k<<],Maxn[k<<|]);
    }
    int Qpos(int k,int l,int r,int w){
        if(l==r) return l;
        int mid=l+r>>;
        if(Maxn[k<<]>=w) return Qpos(k<<,l,mid,w);
        if(Maxn[k<<|]>=w) return Qpos(k<<|,mid+,r,w);
        return -;
    }
}Segment;
signed main(){
//    freopen("transfer.in","r",stdin);
//    freopen("transfer.out","w",stdout);
    N=read();int l=;
    for(int i=;i<=N;i++){
        int opt=read(),w=read(),t=read();
        if(opt==){g[++tot].w=w,g[tot].t=t;Segment.Modify(,,N,tot,tot,w);Ans+=w;continue;}
        while(l<=tot&&t-g[l].t>){Segment.Modify(,,N,l,l,);l++;}
        int u=Segment.Qpos(,,N,w);
        if(u==-) {Ans+=w;;continue;}
        Segment.Modify(,,N,u,u,);continue;
//        printf("i:%d l:%d\n",i,l);
    }printf("%lld\n",Ans);return ;
}

纪念品

若 $i$ 天买进 $j$ 天卖出可以看成 $i$ 天买 ,$i+1$ 天卖后再买。做 $T-1$ 次完全背包即可。时间复杂度 $O(10^4\cdot T\cdot N)$

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
inline int read(){
    int f=,ans=;char c=getchar();
    while(c<''||c>''){if(c=='-')f=-;c=getchar();}
    while(c>=''&&c<=''){ans=ans*+c-'';c=getchar();}
    return f*ans;
}
const int MAXA=;
const int MAXN=;
int T,N,M,f[MAXA],A[MAXN][MAXN],Maxn;
int main(){
//    freopen("4.in","r",stdin);
    T=read(),N=read(),M=read();
    if(T==){printf("%d\n",M);return ;}
    for(int i=;i<=T;i++)
        for(int j=;j<=N;j++) A[i][j]=read();Maxn=M;
    for(int i=;i<T;i++){
        memset(f,,sizeof(f));
        for(int j=;j<=Maxn;j++) f[j]=j;
        for(int j=;j<=Maxn;j++)
            for(int k=;k<=N;k++) if(j>=A[i][k]){
                f[j]=max(f[j],f[j-A[i][k]]+A[i+][k]);
            }
        for(int j=;j<=Maxn;j++) Maxn=max(Maxn,f[j]);
    }printf("%d\n",Maxn);return ;
}/*
6 1 100
50
20
25
20
25
50
*/

加工零件

分奇偶跑最短路即可，时间复杂度 $O(n+m+q)$ 。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
#define int long long
using namespace std;
inline int read(){
    int f=,ans=;char c=getchar();
    while(c<''||c>''){if(c=='-')f=-;c=getchar();}
    while(c>=''&&c<=''){ans=ans*+c-'';c=getchar();}
    return f*ans;
}
const int MAXN=;
struct node{
    int u,v,w,nex;
}x[MAXN<<];
int head[MAXN],cnt,f[MAXN][];
void add(int u,int v,int w){
    x[cnt].u=u,x[cnt].v=v,x[cnt].w=w,x[cnt].nex=head[u],head[u]=cnt++;
}
int n,m,vis[MAXN][],q,siz[MAXN];
priority_queue<pair<int,pair<int,int> > > Que;
void dijkstra(){
    memset(f,/,sizeof(f));f[][]=;Que.push(make_pair(,make_pair(,)));
    while(!Que.empty()){
        int u=Que.top().second.first,opt=Que.top().second.second;Que.pop();if(vis[u][opt]) continue;
        vis[u][opt]=;
        for(int i=head[u];i!=-;i=x[i].nex){
            int W=f[u][opt]+x[i].w;
            if(f[x[i].v][W&]>W){
                f[x[i].v][W&]=W;Que.push(make_pair(-f[x[i].v][W&],make_pair(x[i].v,W&)));
            }
        }
    }
}
signed main(){
//    freopen("work.in","r",stdin);
//    freopen("work.out","w",stdout);
    memset(head,-,sizeof(head));
    n=read(),m=read(),q=read();
    for(int i=;i<=m;i++){
        int u=read(),v=read();
        add(u,v,),add(v,u,);siz[u]++,siz[v]++;
    }
    dijkstra();
    while(q--){
        int u=read(),L=read();
        if(u==&&siz[]==){printf("No\n");continue;}
        if(f[u][L&]<=L){printf("Yes\n");continue;}
        printf("No\n");continue;
    }
}/*
10 6 5

4 7
2 4
4 5
3 2
5 7
8 6

3 1
8 2
4 1
5 1
1 4

*/