Noip模拟39 2021.8.14

T1 打地鼠

都切掉了的简单题

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int NN=2005;
int n,k,g[NN][NN],ans,sum[NN][NN];
char s[NN];
inline int calc(int x1,int y1,int x2,int y2){
    return sum[x2][y2]-sum[x1-1][y2]-sum[x2][y1-1]+sum[x1-1][y1-1];
}
namespace WSN{
    inline short main(){
        scanf("%lld%lld",&n,&k);
        for(int i=1;i<=n;i++){
            scanf("%s",s+1);
            for(int j=1;j<=n;j++){
                g[i][j]=s[j]-'0';
                sum[i][j]=sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+g[i][j];
            }
        }
        for(int i=1;i<=n-k+1;i++)
            for(int j=1;j<=n-k+1;j++)
                ans=max(ans,calc(i,j,i+k-1,j+k-1));
        printf("%lld\n",ans);
        return 0;
    }
}
signed main(){return WSN::main();}

 

T2 竞赛图

首先把图中能够当作强联通图的部分缩点来看，

这样化简后的图，如果两个点之间只有一种方向的边，那么他们形成的子图是不合法的

转移的时候用强联通的子集更新非强联通的点集，枚举所有从强联通图出来的边，考虑记录当前枚举的点集合法与否即可

#include<bits/stdc++.h>
using namespace std;
const int NN=25;
int T,n,ans,U,to[1<<24];
bool bin[1<<24];
namespace WSN{
    inline short main(){
        scanf("%d",&T);
        while(T--){
            memset(to,0,sizeof(to)); memset(bin,1,sizeof(bin));
            scanf("%d",&n);ans=0;U=(1<<n)-1; to[0]=U;
            for(int i=0;i<n;i++) for(int j=0,t;j<n;j++){scanf("%d",&t);if(t) to[1<<i]|=1<<j;}
            for(int s=1,ss;s<=U;s++) ss=s&(-s),to[s]=to[s^ss]&to[ss];
            for(int s=1;s<=U;s++) if(bin[s])
                for(int i=to[s];i;i--,i&=to[s]) bin[s|i]=0;
            for(int s=0;s<=U;s++) ans+=bin[s]; printf("%d\n",ans);
        }
        return 0;
    }
}
signed main(){return WSN::main();}

 

T3 糖果

沽沽沽

 

T4 树

极其类似染色这道题，

我们可以在初始建树的时候给每个点附上一个自己的编号为点权

那么图中的点权范围是从一到$n$的

考虑每次修改操作将路径上的所有点赋值成一个大于$n$的新数，

这样我们可以发现每次对于黑边的查找，实质上是找路径上有几个点对点权不一样

线段树上维护一个$lc,rc,sum$分别表示区间首点权，区间尾点权，区间内黑色边数即可

#include<bits/stdc++.h>
using namespace std;
const int NN=300001;
int n,q,du[NN];
int dfn[NN],rk[NN],son[NN],fa[NN],top[NN],siz[NN],dep[NN],cnt;
struct SNOW{int to,next;};SNOW e[NN<<1]; int head[NN],rp;

inline void add(int x,int y){e[++rp]=(SNOW){y,head[x]}; head[x]=rp;}
inline void dfs1(int f,int x){
    fa[x]=f; dep[x]=dep[f]+1; siz[x]=1;
    for(int i=head[x];i;i=e[i].next){
        int y=e[i].to;if(y==f) continue;
        dfs1(x,y);
        siz[x]+=siz[y];
        if(siz[son[x]]<siz[y]) son[x]=y;
    }
}
inline void dfs2(int x,int t){
    top[x]=t; dfn[x]=++cnt; rk[cnt]=x;
    if(son[x]) dfs2(son[x],t);
    for(int i=head[x];i;i=e[i].next){
        int y=e[i].to;
        if(y!=fa[x]&&y!=son[x]) dfs2(y,y);
    }
}
struct SNOWtree{
    #define lid (id<<1)
    #define rid (id<<1|1)
    int ll[NN<<2],rr[NN<<2],sm[NN<<2],laz[NN<<2];
    int lc[NN<<2],rc[NN<<2];
    inline void pushup(int id){
        lc[id]=lc[lid]; rc[id]=rc[rid];
        sm[id]=sm[lid]+sm[rid]+(lc[rid]!=rc[lid]);
    }
    inline void pushdown(int id){
        if(laz[id]==-1 || ll[id]==rr[id]) return;
        laz[lid]=laz[rid]=laz[id];
        sm[lid]=sm[rid]=0;
        lc[lid]=rc[lid]=laz[id];
        lc[rid]=rc[rid]=laz[id];
        laz[id]=-1;
    }
    inline void build(int id,int l,int r){
        ll[id]=l; rr[id]=r; laz[id]=-1;
        if(l==r){lc[id]=rc[id]=l;return;}
        int mid=l+r>>1;
        build(lid,l,mid); build(rid,mid+1,r);
        pushup(id);
    }
    inline void change(int id,int l,int r,int v){
        if(l<=ll[id]&&rr[id]<=r){lc[id]=rc[id]=laz[id]=v;sm[id]=0;return;}
        pushdown(id); int mid=ll[id]+rr[id]>>1;
        if(l<=mid) change(lid,l,r,v);
        if(r>mid) change(rid,l,r,v);
        pushup(id);
    }
    inline int query(int id,int l,int r){
        if(l<=ll[id]&&rr[id]<=r) return sm[id];
        pushdown(id); int mid=ll[id]+rr[id]>>1,ans=0;
        if(r<=mid) return query(lid,l,r);
        if(l>mid) return query(rid,l,r);
        return query(lid,l,mid)+query(rid,mid+1,r)+(lc[rid]!=rc[lid]);
    }
    inline int look(int id,int pos){
        if(ll[id]==rr[id]) return lc[id];
        pushdown(id); int mid=ll[id]+rr[id]>>1;
        if(pos<=mid) return look(lid,pos);
        else return look(rid,pos);
    }
}tr;
inline void update(int x,int y,int v){
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        tr.change(1,dfn[top[x]],dfn[x],v);
        x=fa[top[x]];
    }if(dfn[x]>dfn[y]) swap(x,y);
    tr.change(1,dfn[x],dfn[y],v);
}
inline int query(int x,int y){
    int sum=0;
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        sum+=tr.query(1,dfn[top[x]],dfn[x])+(tr.look(1,dfn[top[x]])!=tr.look(1,dfn[fa[top[x]]]));
        x=fa[top[x]];
    }if(dfn[x]>dfn[y]) swap(x,y);
    sum+=tr.query(1,dfn[x],dfn[y]);
    return sum;
}
namespace WSN{
    inline short main(){
/*        freopen("1.in","r",stdin);
        freopen("1.out","w",stdout);*/
        scanf("%d",&n);
        for(int i=1,x,y;i<n;i++){
            scanf("%d%d",&x,&y);
            add(x,y); add(y,x);
        }
        int color=n; scanf("%d",&q);
        dfs1(0,1); dfs2(1,1); tr.build(1,1,n);
        while(q--){
            int typ,x,y;scanf("%d%d%d",&typ,&x,&y);
            if(typ==1){
                update(x,y,++color);
/*for(int i=1;i<=n*4;i++) if(tr.ll[i]) cout<<tr.ll[i]<<" "<<tr.rr[i]<<" "<<tr.pr[i]<<" "<<tr.nx[i]<<" "<<tr.co[i]<<" "<<tr.laz[i]<<endl;*/
            }
            if(typ==2) printf("%d\n",query(x,y));
        }
        return 0;
    }
}
signed main(){return WSN::main();}