20170715离线赛比赛总结

A

结果和评价

  • 结果 100 ,时间 30 + 10

我的想法与思路

  • 直接暴力,然后造数据跑跑发现没有问题就没有想这么多了。

B

结果和评价

  • 结果 10 ,时间 30 + 30 评价:非常不应该

我的想法与思路

  • 我们通过一些不必要的复杂方法得到了三个关系
  • 又暂时没有想到正解打算切点分
  • 之后可以过85分。可是作死切了一个暴力,同时调试的时候代码没有还原,结果只有10分。。QAQ

反思

  • 时间安排要好,我在这一题85分的代码已经写好了以后花了太多的时间瞎调试,最后没有检验导致错误。
  • 暴力的正确性很重要,同时没有太大的必要可以不去敲暴力的。

正确的思路

  • 我们可以得到这样的一个样子 AB...CD
    长度 为 x
  • 我们可以发现枚举了x之后 AB 相对位置固定, CD 相对位置固定这样我们可以枚举每个 AB 的合法 CD
  • 这样问题就可以 nn/9 的处理了。
const int M=15005;
int A[M],B[M],C[M],D[M],cnt[M],h[3*M],n,m;
int main(){
    rd(n);rd(m);
    for(int i=1;i<=m;i++)rd(h[i]),cnt[h[i]]++;

    for(int x=1,len,res;x<=n/9;x++) {
        len=1+9*x,res=0;
        for(int a,b,c,d=1+len;d<=n;d++){
            a=d-len;
            b=a+2*x;
            c=d-x;
            res+=cnt[a]*cnt[b];
            C[c]+=res*cnt[d];
            D[d]+=res*cnt[c];
        }
        res=0;
        for(int a=n-len,b,c,d;a>=1;a--){
            b=a+2*x;
            c=a+8*x+1;
            d=c+x;
            res+=cnt[c]*cnt[d];
            A[a]+=res*cnt[b];
            B[b]+=res*cnt[a];
        }
    }
    for(int i=1;i<=m;i++){
        int x=h[i];
        pt(A[x]);
        pt(B[x]);
        pt(C[x]);
        ptn(D[x]);
    }
    return 0;
}

C

结果和评价

  • 结果 30 ,时间 80 评价:基本分

我的想法与思路

  • 直接去切60分,直接想到 tarjan 尴尬的是 tarjan 忘了怎么写了。

反思

  • 算法模板要牢记
  • 时间复杂度一定要估计准确。。。不要写完了发现时间超限。。

60分思路

  • tarjan 缩点并求桥。
  • 缩点后得到了树,树上的每个点都是关建边。
  • 于是我们只有求树上两点间的距离即可: dep[x]+dep[y]2dep[LCA(x,y)]
const int M=30005,S=20;
int dfn[M],low[M],Dfn,fa[M][S],n,m,q,par[M],dep[M];
int T[M],num,stk[M],top,tree;
vector<int>G[M];
vector<int>g[M]; 
void tarjan(int x,int f=0){
    dfn[x]=low[x]=++Dfn;
    stk[++top]=x;
    for(int i=0;i<G[x].size();i++){
        int y=G[x][i];
        if(y==f)continue;
        if(dfn[y])Min(low[x],dfn[y]);
        else{
            tarjan(y,x);
            Min(low[x],low[y]);
            if(low[y]>dfn[x]){
                /*如果不是和x同一块就开始缩点*/
                ++tree;
                while(low[stk[top]]>dfn[x])T[stk[top--]]=tree;
                /*顺便建树*/
                g[T[f]].push_back(tree);
            }
        }
    }
}
void dfs(int x,int f=0){
    dep[x]=dep[f]+1;
    fa[x][0]=f;
    for(int i=0;i<g[x].size();i++){
        int y=g[x][i];
        if(y!=f)dfs(y,x);
    }   
}
int up(int a,int s){
    for(int i=0;i<S;i++)
        if(s&(1<<i))a=fa[a][i];
    return a;
}
int LCA(int a,int b){
    if(dep[a]>dep[b])swap(a,b);
    b=up(b,dep[b]-dep[a]);
    if(a!=b){
        for(int i=S-1;i>=0;i--)
            if(fa[a][i]!=fa[b][i])
                a=fa[a][i],b=fa[b][i];
        a=fa[a][0];
    }return a;
}
int main(){

    rd(n);rd(m);rd(q);

    for(int i=1,x,y;i<=m;i++){
        rd(x);rd(y);
        G[y].push_back(x);
        G[x].push_back(y);
    }

    tarjan(1);
    tree++;
    while(top)T[stk[top--]]=tree;

    dfs(T[1]);

    for(int i=1;i<S;i++)
        for(int j=1;j<=n;j++)
            fa[j][i]=fa[fa[j][i-1]][i-1];

    while(q--){
        int x,y;
        rd(x);
        rd(x);
        rd(y);
        x=T[x];
        y=T[y];
        ptn(dep[x]+dep[y]-2*dep[LCA(x,y)]);
    }
    return 0;           
}

100分思路

  • 既然都想到利用 tarjan 把图变成树了,我们想想这一题是否可以和树联系在一起。
  • 由于树上的都是关建边,我们不妨考虑其极端的状态,比如:题目给出的图就是树,或者最后删成了树。
  • 如果最后删成了树,那么最后几个询问就很容易回答了。
  • 此时我们可以想想在树上多条边对答案的贡献。
    这里写图片描述
  • 对于这样的一个树,看看如果我们加上一条边有什么用
    这里写图片描述
  • 有了3-4后,1-4,1-2,2-3,都没有用了,这样的话从5到1,2,4的 cost 都减少了。
  • 但是我们发现对边进行操作很困难。不妨对点的信息进行修改。
    cost=dep[x]+dep[y]2dep[LCA(x,y)]
  • 把1-4,1-2,2-3去掉相当于把4,2,3的 dep 都减掉了1因为这三条边都无需再遍历了。
  • 再举个例子
    这里写图片描述
  • 我们加上边4-6。
    这里写图片描述
  • 我们发现 dep41 , dep21 , dep63 , dep32 ,即每个受影响的点,他们的子树中的, dep 都要减掉1。
  • 于是我们可以 dfn 套上 Bit 记录每个点被的减掉了几个
  • 由于每个边在无效之后就没有意义了,所以可以通过并查集来压缩路径。
  • 之后我们通过倒着操作,对于每个删边的操作或者询问的操作我们可以 log(n) 的跑出来了。
const int M=3e5+5,S=19;
int fa[M][S],L[M],R[M],Dfn,dep[M],par[M],n,m,q,ans[M];
vector<int>G[M];
struct node{
    int x,y,cmd;
}Q[M*2];    
set<int>mark[M];
void dfs(int x,int f){
    par[x]=x;
    dep[x]=dep[f]+1,fa[x][0]=f;
    L[x]=++Dfn;
    for(int i=0;i<G[x].size();i++){
        int y=G[x][i];
        if(dep[y]||mark[x].find(y)!=mark[x].end())continue;
//      bug(x);
//      debug(y);
        if(y!=f)dfs(y,x);
    }
    R[x]=Dfn;
}
int find(int x){
    if(x==par[x])return x;
    return par[x]=find(par[x]);
}
struct Bit{
    int m[M];
    void add(int x,int d){
        for(int i=x;i<M;i+=i&-i)m[i]+=d;
    }
    int query(int x){
        int res=0;
        for(int i=x;i;i-=i&-i)res+=m[i];
        return res;
    }
}sum;
void up(int &x,int s){
    for(int i=0;i<S;i++)
        if(s&(1<<i))x=fa[x][i];
}
int LCA(int x,int y){
    if(dep[x]<dep[y])swap(x,y);
    up(x,dep[x]-dep[y]);
    if(x==y)return x;
    for(int i=S-1;i>=0;i--)
        if(fa[x][i]!=fa[y][i])
            x=fa[x][i],y=fa[y][i];
    return fa[x][0];
}
void Add(int x,int y){
    int anc=LCA(x,y);
    while(dep[x=find(x)]>dep[anc]){
        sum.add(L[x],1);
        sum.add(R[x]+1,-1);
        par[x]=fa[x][0];
    }
    x=y;
    while(dep[x=find(x)]>dep[anc]){
        sum.add(L[x],1);
        sum.add(R[x]+1,-1);
        par[x]=fa[x][0];
    }
}
int calc(int x,int y){

    int lca=LCA(x,y);
//  bug(x);
//  bug(y);
//  debug(lca);
//  bug(dep[x]);
//  bug(dep[y]);
//  debug(dep[lca]);
//  bug(sum.query(x));
//  bug(sum.query(y));
//  debug(sum.query(lca));
    return dep[x]-sum.query(L[x])+dep[y]-sum.query(L[y])-2*(dep[lca]-sum.query(L[lca]));
}
int main(){
    rd(n);rd(m);rd(q);
    for(int i=1,y,x;i<=m;i++){
        rd(x);rd(y);
        G[x].push_back(y);
        G[y].push_back(x);
    }
    for(int i=1,cmd,x,y;i<=q;i++){
        rd(Q[i].cmd);rd(Q[i].x);rd(Q[i].y);
        if(!Q[i].cmd)mark[Q[i].x].insert(Q[i].y),mark[Q[i].y].insert(Q[i].x);
    }

    dfs(1,0);

    for(int i=1;i<S;i++)
        for(int j=1;j<=n;j++)
            fa[j][i]=fa[fa[j][i-1]][i-1];

//  puts("more");
    for(int x=1;x<=n;x++){
        for(int i=0;i<G[x].size();i++){
            int y=G[x][i];
            if(x<y&&fa[x][0]!=y&&fa[y][0]!=x&&mark[x].find(y)==mark[x].end())Add(x,y);
        }
    }
//  puts("delt");

    for(int i=q;i>=1;i--){
        if(Q[i].cmd)ans[i]=calc(Q[i].x,Q[i].y);
        else Add(Q[i].x,Q[i].y);
    }

    for(int i=1;i<=q;i++)
        if(Q[i].cmd)printf("%d\n",ans[i]);

    return 0;
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值