复健训练 CF1709

A Three Doors

题意：三个门，每个门后面有一扇门的钥匙，手上有其中一扇钥匙，求是否能打开三扇门、

类似于一个dag的问题，求是否可以从一个起点遍历，使用任何图的算法都可以解决

#include <bits/stdc++.h>

using namespace std;
#define gc getchar()
#define re register
#define int long long
inline int read() {
    int x=0,f=1;char c(gc);
    while(c>'9'||c<'0')f=c=='-'?-1:1,c=gc;
    while(c<='9'&&c>='0')x=x*10+c-48,c=gc;
    return x*f;
}

int f[4][4];

signed main() {
    int T=read();
    while(T--) {
        int x=read(),a=read(),b=read(),c=read();
        memset(f,0,sizeof(f));
        f[1][a]=f[1][1]=1;
        f[2][b]=f[2][2]=1;
        f[3][c]=f[3][3]=1;
        for(int k=1;k<=3;++k)
            for(int i=1;i<=3;++i)
                for(int j=1;j<=3;++j)
                    f[i][j]=f[i][j]|(f[i][k]&f[k][j]);
        int flag=0;
        for(int i=1;i<=3;++i) if(!f[x][i]) flag=1;
        if(flag) puts("NO");
        else puts("YES");
    }
    return 0;
} 

B Also Try Minecraft

 

题意：n列，每列有个高度值，每次询问从一列飞到另外一列过程中需要下降的总高度值

 前缀和处理，O(1) 查询

#include <bits/stdc++.h>

using namespace std;
#define gc getchar()
#define re register
#define int long long
inline int read() {
    int x=0,f=1;char c(gc);
    while(c>'9'||c<'0')f=c=='-'?-1:1,c=gc;
    while(c<='9'&&c>='0')x=x*10+c-48,c=gc;
    return x*f;
}

const int N=2e5+10;
int n,m,a[N],s1[N],s2[N];


signed main() {
    n=read(),m=read();
    for(int i=1;i<=n;++i) {
        a[i]=read(); 
        if(a[i]<a[i-1]) s1[i]=s1[i-1]+a[i-1]-a[i];
        else s1[i]=s1[i-1];
    }
    for(int i=n;i>=1;--i) {
        if(a[i]<a[i+1]) s2[i]=s2[i+1]+a[i+1]-a[i];
        else s2[i]=s2[i+1]; 
    }
    while(m--) {
        int l=read(),r=read();
        if(l<r) cout<<s1[r]-s1[l]<<'\n';
        else cout<<s2[r]-s2[l]<<'\n';
    }
    return 0;
}

C Recover an RBS

题意：询问对于一个有部分残缺的括号序列是否有唯一填法

考虑如果结果不唯一会如何，贪心的填，在左半边全部（，右半边全部）是假如解法唯一的唯一解，那么在不满足这个唯一解的情况下最有可能出现变动的解就是把最中间的两个括号交换位置，假如这样满足，那么不唯一，否则唯一

#include <bits/stdc++.h>

using namespace std;
#define gc getchar()
#define re register
#define int long long
inline int read() {
    int x=0,f=1;char c(gc);
    while(c>'9'||c<'0')f=c=='-'?-1:1,c=gc;
    while(c<='9'&&c>='0')x=x*10+c-48,c=gc;
    return x*f;
}

const int N=2e5+10;
char s[N];
int f[N],q[N],n;

signed main() {
    int T=read();
    while(T--) {
        scanf("%s",s+1);
        n=strlen(s+1);
        int ct=0,tp=0;
        for(int i=1;i<=n;++i) {
            if(s[i]=='(') ++ct;
            else if(s[i]==')') --ct;
            else q[++tp]=i;
        }
        if(fabs(ct)==tp) {
            puts("YES");
            continue;
        }
        int l=(tp-ct)>>1;
        for(int i=1;i<=l;++i) s[q[i]]='(';
        for(int i=l+1;i<=tp;++i) s[q[i]]='(';
        s[q[l+1]]='(',s[q[l]]=')';
        int flag=0;ct=0;
        for(int i=1;i<=n;++i) {
            if(s[i]=='(') ++ct;
            else --ct;
            if(ct<0) flag=1;
        }
        if(flag) puts("YES");
        else puts("NO");
    }
    return 0;
}

D Rorororobot

题意：对于一个网格，每列有从下往上一定的高度的障碍物，求在每次必须走k步的情况下能否从一个点到达另外一个点

对于每次移动，和步数相关的只有在这个区间内最高的障碍物，可以用线段树，ST表等维护，然后判断这个过程是不是k的倍数

#include <bits/stdc++.h>

using namespace std;
#define gc getchar()
#define re register
#define int long long
inline int read() {
    int x=0,f=1;char c(gc);
    while(c>'9'||c<'0')f=c=='-'?-1:1,c=gc;
    while(c<='9'&&c>='0')x=x*10+c-48,c=gc;
    return x*f;
}

const int N=2e5+10;
int n,a[N],xs,ys,xt,yt,k,m;

#define ls id<<1
#define rs id<<1|1
#define mid ((l+r)>>1)
int mx[N<<2];
void pushup(int id) {mx[id]=max(mx[ls],mx[rs]);}
void built(int id,int l,int r) {
    if(l==r) {
        mx[id]=a[l];
        return;
    }
    built(ls,l,mid);
    built(rs,mid+1,r);
    pushup(id);
}
int query(int id,int l,int r,int L,int R) {
    if(l>=L&&r<=R) return mx[id];
    if(mid>=R) return query(ls,l,mid,L,R);
    if(mid<L) return query(rs,mid+1,r,L,R);
    return max(query(ls,l,mid,L,R),query(rs,mid+1,r,L,R));
}

signed main() {
    n=read();m=read();
    for(int i=1;i<=m;++i) a[i]=read();
    built(1,1,n);
    int q=read();
    while(q--) {
        ys=read(),xs=read(),yt=read(),xt=read(),k=read();
        if(xt<xs) swap(xs,xt),swap(ys,yt);
        int m=query(1,1,n,xs,xt);
        if(abs(xs-xt)%k||abs(ys-yt)%k) puts("NO");
        else {
            int hi=(n-ys)/k*k+ys;
            if(hi<=m) puts("NO");
            else puts("YES");
        }
    }
    return 0; 
}

E XOR Tree

给一棵树，每个节点上有一个权值，求最少的权值修改次数，使得树上没有一条路径异或为零

（不知道为啥想到春节十二响，虽然我已经忘了这个题目）

对于一个节点，如果进行修改，直接修改成 2^30+x，这样对于再往上走节点相当于清空，我们考虑什么样的点需要进行修改，对于一个节点 u,v ，如果 a[lca(u,v)] ^ w[u] ^ w[v] 那么进行修改，对于一个节点，对其儿子进行判断是否存在这样的情况，如果存在那么对其修改（贪心修改最上面的），然后对这个节点清空，因为这样一来包含他的路径一定不可能出现0。操作使用启发式合并。

#include <bits/stdc++.h>

using namespace std;
#define gc getchar()
#define re register
#define int long long
inline int read() {
    int x=0,f=1;char c(gc);
    while(c>'9'||c<'0')f=c=='-'?-1:1,c=gc;
    while(c<='9'&&c>='0')x=x*10+c-48,c=gc;
    return x*f;
}

const int N=2e5+10;
int n,a[N],hd[N],cnt,siz[N],w[N],ans;
struct node {int next,to;}e[N<<1];
void add(int u,int v) {
    e[++cnt]=(node){hd[u],v},hd[u]=cnt;
    e[++cnt]=(node){hd[v],u},hd[v]=cnt; 
}
#define QX(u) for(int i=hd[u],v;v=e[i].to,i;i=e[i].next)

set <int> s[N];

void dfs(int u,int fa) {
    siz[u]=1;
    s[u].insert(w[u]);
    bool flag=0;
    QX(u) if(v^fa) {
        w[v]=w[u]^a[v];
        dfs(v,u);
        if(s[u].size()<s[v].size()) swap(s[u],s[v]);
        for(int x:s[v]) if(s[u].find(x^a[u])!=s[u].end()) flag=1;
        for(int x:s[v]) s[u].insert(x);
    }
    if(flag) {
        s[u].clear();
        ++ans; 
    }
}

signed main() {
    n=read();
    for(int i=1;i<=n;++i) a[i]=read();
    for(int i=1,u,v;i<n;++i) u=read(),v=read(),add(u,v); 
    dfs(1,1);
    cout<<ans<<'\n';
    return 0;
}