[ONTAK2010]Highways

最新推荐文章于 2019-08-13 11:59:14 发布
最新推荐文章于 2019-08-13 11:59:14 发布
阅读量648 收藏
点赞数
分类专栏： BIT 扫描线 分块 主席树 文章标签： bit 扫描线 分块
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TA201314/article/details/51261176
版权
BIT 同时被 3 个专栏收录
11 篇文章 0 订阅
订阅专栏
分块
11 篇文章 0 订阅
订阅专栏
扫描线
4 篇文章 0 订阅
订阅专栏

想学线段树合并找的一个题。。没想到是个傻逼题。

这题题意好像有问题：额外的点对和查询的点对都不会是同一个点。

设x的dfs序为dfn(x)，x的子树中dfs序最大的节点的dfs序为dr(x)。将额外的边(u,v)看作点 (dfn(u),dfn(v))(dfn(u)≤dfn(v)) 。对于一次查询 (u,v)(dfn(u)≤dfn(v)) ，如果lca(u,v)==u，那么就找到v的一个祖先x使得fa(x)=u，然后就相当于询问矩形[dfn(v),dr(v)]-[1,dfn(x)-1]+[dfn(v),dr(v)]-[dr(x)+1,n]矩形中点的个数；如果lca(u,v)!=v，那么就相当于询问[dfn(v),dr(v)]-[dfn(u),dr(u)]中点的个数。所以就是平面上有一些点，然后每次询问一个矩形中有多少点。。就成了noip难度的题了。。
一个非常直观的想法就是扫描线+bit，把每个矩形拆成两次询问。这样做的时间复杂度是 O(n+(m+q)log2n) 。如果要求在线的话就换成主席树就可以了。
但是我为什么要为这样一道水题写解题报告呢？——因为注意到m与q不同阶，所以又到了喜闻乐见的分块大战bit的时候了！我们实际上面临 105 次插入和 2∗106 次查询，所以如果我们分块，时间复杂度 O(n+mn√+q) ！
能不能跑过bit呢？答案当然还是一如既往的。。并不能。。

代码（bit）：

#include<cstdio>
#include<iostream>
using namespace std;
#include<algorithm>
#include<cstring>
#include<cmath>
const int N=1e5+5,M=1e5+5,Q=5e5+5;
int n;

char * cp=(char *)malloc(10000000);
void in(int &x){
    while(*cp<'0'||*cp>'9')++cp;
    for(x=0;*cp>='0'&&*cp<='9';)x=x*10+(*cp++^'0');
}
char * os=(char *)malloc(4000000),* op=os;
void out(int x){
    if(x){
        out(x/10);
        *op++='0'+x%10;
    }
}

int next[N<<1],succ[N<<1],ptr[N],etot=1;
void addedge(int from,int to){
    next[etot]=ptr[from],ptr[from]=etot,succ[etot++]=to;
}
int dfn[N],dr[N],dtot=1;
const int Log=17;
int top[N],size[N],fa[N];
void sizedfs(int node){
    size[node]=1;
    for(int i=ptr[node];i;i=next[i])
        if(succ[i]!=fa[node]){
            fa[succ[i]]=node;
            sizedfs(succ[i]);
            size[node]+=size[succ[i]];
        }
}
void builddfs(int node){
    //printf("%d ",node);

    dfn[node]=dtot++;

    if(!top[node])top[node]=node;
    int bigson=0;
    for(int i=ptr[node];i;i=next[i])
        if(fa[node]!=succ[i]&&size[succ[i]]>size[bigson])
            bigson=succ[i];
    if(bigson){
        builddfs(bigson);
        for(int i=ptr[node];i;i=next[i])
            if(fa[node]!=succ[i]&&bigson!=succ[i])
                builddfs(succ[i]);
    }

    dr[dfn[node]]=dtot-1;
}

int bit[N];
void add(int x){
    for(;x<=n;x+=x&-x)++bit[x];
}
int query(int x){
    int ans=0;
    for(;x;x-=x&-x)ans+=bit[x];
    return ans;
}

struct PS{
    int x,y;//x>=y
    bool operator < (const PS & o)const{
        return x<o.x;
    }
}point[M];

struct QS{
    int x,yl,yr;
    int coe;
    int i;
    bool operator < (const QS & o)const{
        return x<o.x;
    }
}que[Q<<2];
int qtot;
int ans[Q];

int main(){
    freopen("bzoj_3488.in","r",stdin);
    freopen("bzoj_3488_bit.out","w",stdout);
    fread(cp,1,10000000,stdin);
    in(n);
    int u,v;
    for(int i=n;--i;){
        in(u),in(v);
        addedge(u,v),addedge(v,u);
    }

    sizedfs(1);
    builddfs(1);
    //puts("");

    int m;
    in(m);
    for(int i=m;i--;){
        in(point[i].x),in(point[i].y);
        if((point[i].x=dfn[point[i].x])<(point[i].y=dfn[point[i].y]))swap(point[i].x,point[i].y);
        //printf("(%d,%d)\n",point[i].x,point[i].y);
    }
    int q;
    in(q);
    for(int i=0;i<q;++i)ans[i]=1;
    int x;
    for(int i=0;i<q;++i){
        in(u),in(v);
        if(dfn[u]>dfn[v])swap(u,v);
        //printf("(%d,%d):",u,v);
        if(dr[dfn[u]]>=dr[dfn[v]]){
            if(dr[dfn[u]+1]>=dr[dfn[v]])x=dfn[u]+1;
            else{
                x=v;
                while(fa[top[x]]!=u)x=fa[top[x]];
                x=dfn[x];
            }
            //printf("%d\n",x);
            que[qtot++]=(QS){dfn[v]-1,1,x-1,-1,i};
            que[qtot++]=(QS){dr[dfn[v]],1,x-1,1,i};
            que[qtot++]=(QS){dr[x],dfn[v],dr[dfn[v]],-1,i};
            que[qtot++]=(QS){n,dfn[v],dr[dfn[v]],1,i};
        }
        else{
            //puts("Two subtree");
            que[qtot++]=(QS){dfn[v]-1,dfn[u],dr[dfn[u]],-1,i};
            que[qtot++]=(QS){dr[dfn[v]],dfn[u],dr[dfn[u]],1,i};
        }
    }

    sort(point,point+m),sort(que,que+qtot);
    for(int i=1,j=0,k=0;i<=n;++i){
        for(;point[j].x==i;++j)add(point[j].y);
        for(;que[k].x==i;++k)ans[que[k].i]+=que[k].coe*(query(que[k].yr)-query(que[k].yl-1));
    }

    for(int i=0;i<q;++i){
        if(ans[i])out(ans[i]);
        else *op++='0';
        *op++='\n';
    }
    fwrite(os,1,op-os,stdout);
}

代码（分块）：

#include<cstdio>
#include<iostream>
using namespace std;
#include<algorithm>
#include<cstring>
#include<cmath>
const int N=1e5+5,M=1e5+5,Q=5e5+5;
int n;

char * cp=(char *)malloc(10000000);
void in(int &x){
    while(*cp<'0'||*cp>'9')++cp;
    for(x=0;*cp>='0'&&*cp<='9';)x=x*10+(*cp++^'0');
}
char * os=(char *)malloc(4000000),* op=os;
void out(int x){
    if(x){
        out(x/10);
        *op++='0'+x%10;
    }
}

int next[N<<1],succ[N<<1],ptr[N],etot=1;
void addedge(int from,int to){
    next[etot]=ptr[from],ptr[from]=etot,succ[etot++]=to;
}
int dfn[N],dr[N],dtot=1;
const int Log=17;
int top[N],size[N],fa[N];
void sizedfs(int node){
    size[node]=1;
    for(int i=ptr[node];i;i=next[i])
        if(succ[i]!=fa[node]){
            fa[succ[i]]=node;
            sizedfs(succ[i]);
            size[node]+=size[succ[i]];
        }
}
void builddfs(int node){
    //printf("%d ",node);

    dfn[node]=dtot++;

    if(!top[node])top[node]=node;
    int bigson=0;
    for(int i=ptr[node];i;i=next[i])
        if(fa[node]!=succ[i]&&size[succ[i]]>size[bigson])
            bigson=succ[i];
    if(bigson){
        builddfs(bigson);
        for(int i=ptr[node];i;i=next[i])
            if(fa[node]!=succ[i]&&bigson!=succ[i])
                builddfs(succ[i]);
    }

    dr[dfn[node]]=dtot-1;
}

const int B=320;
int bs[505],s[505][505];
void add(int x){
    for(int i=x/B;i<=n/B;++i)++bs[i+1];
    for(int j=x%B+1;j<=B;++j)++s[x/B+1][j];
}
int query(int x){
    return bs[x/B]+s[x/B+1][x%B+1];
}

struct PS{
    int x,y;//x>=y
    bool operator < (const PS & o)const{
        return x<o.x;
    }
}point[M];

struct QS{
    int x,yl,yr;
    int coe;
    int i;
    bool operator < (const QS & o)const{
        return x<o.x;
    }
}que[Q<<2];
int qtot;
int ans[Q];

int main(){
    freopen("bzoj_3488.in","r",stdin);
    freopen("bzoj_3488.out","w",stdout);
    fread(cp,1,10000000,stdin);
    in(n);
    int u,v;
    for(int i=n;--i;){
        in(u),in(v);
        addedge(u,v),addedge(v,u);
    }

    sizedfs(1);
    builddfs(1);
    //puts("");

    int m;
    in(m);
    for(int i=m;i--;){
        in(point[i].x),in(point[i].y);
        if((point[i].x=dfn[point[i].x])<(point[i].y=dfn[point[i].y]))swap(point[i].x,point[i].y);
        //printf("(%d,%d)\n",point[i].x,point[i].y);
    }
    int q;
    in(q);
    for(int i=0;i<q;++i)ans[i]=1;
    int x;
    for(int i=0;i<q;++i){
        in(u),in(v);
        if(dfn[u]>dfn[v])swap(u,v);
        //printf("(%d,%d):",u,v);
        if(dr[dfn[u]]>=dr[dfn[v]]){
            if(dr[dfn[u]+1]>=dr[dfn[v]])x=dfn[u]+1;
            else{
                x=v;
                while(fa[top[x]]!=u)x=fa[top[x]];
                x=dfn[x];
            }
            //printf("%d\n",x);
            que[qtot++]=(QS){dfn[v]-1,1,x-1,-1,i};
            que[qtot++]=(QS){dr[dfn[v]],1,x-1,1,i};
            que[qtot++]=(QS){dr[x],dfn[v],dr[dfn[v]],-1,i};
            que[qtot++]=(QS){n,dfn[v],dr[dfn[v]],1,i};
        }
        else{
            //puts("Two subtree");
            que[qtot++]=(QS){dfn[v]-1,dfn[u],dr[dfn[u]],-1,i};
            que[qtot++]=(QS){dr[dfn[v]],dfn[u],dr[dfn[u]],1,i};
        }
    }

    sort(point,point+m),sort(que,que+qtot);
    for(int i=1,j=0,k=0;i<=n;++i){
        for(;point[j].x==i;++j)add(point[j].y);
        for(;que[k].x==i;++k)ans[que[k].i]+=que[k].coe*(query(que[k].yr)-query(que[k].yl-1));
    }

    for(int i=0;i<q;++i){
        if(ans[i])out(ans[i]);
        else *op++='0';
        *op++='\n';
    }
    fwrite(os,1,op-os,stdout);
}

总结：
①bit的常数确实比分块小。

TA201314
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
bzoj 3488: [ONTAK2010]Highways 树状数组
beginend
03-17 308
题意 给一棵n个点的树以及m条额外的双向边 q次询问，统计满足以下条件的u到v的路径： 恰经过一条额外的边 不经过树上u到v的路径上的边 n,m&lt;=100000,q&lt;=500000 分析 一道无聊题居然调了我一个晚上，还卡常简直丧心病狂。 注意这题只走树边也算一种方案，所以只要把答案+1就好了。 把dfs序搞出来后就变成了每次询问一个矩形中的点数，只要离线树状数组...
可持久化线段树&主席树、dfs序 Task Highways (aut)
SUNSET
08-12 381
Highways Memory limit: 128 MB Byteland is a small country, with  cities connected by  bidirectional roads. From each city there is just one way of reaching every other city using the road
主席树 动态 模板
我不想打铁
08-13 217
自己整理模板，仅作模板保存使用 #include <bits/stdc++.h> using namespace std; const int maxn = 6e4+5;//主席树最多需要在原空间上开大40倍，原空间本身首先要加大，这题原空间为50000 const int maxm = 1e4+5; int T[maxn],S[maxn],L[maxn*40],R[maxn*40]...
BZOJ 3488 [ONTAK2010]Highways
dilei7762的博客
11-21 134
题目链接 https://www.lydsy.com/JudgeOnline/problem.php?id=3488 题解 考虑每条边对答案的贡献。设询问为lll到rrr。 若lll和rrr不是祖先关系，那么能产生贡献的就是两端点分别在两个子树内的情况。 若lll和rrr是祖先关系，假设lll是rrr的祖先，那么能产生贡献的就是一个端点在...
bzoj3488: [ONTAK2010]Highways
weixin_30339969的博客
11-14 58
题解:我们考虑如果两点直接不是祖先关系 那么对应的答案为非树边能使两个子树的联通的方案数 如果是祖先关系 则可以看成2个非祖先关系的情况 将区间拆分成两个部分 用树状数组维护答案即可 复杂度o(nlogn) #include <algorithm> #include <iostream> #include <cstring> #include &l...
BZOJ3488 : [ONTAK2010]Highways
weixin_30236595的博客
02-26 63
对于询问(x,y)，恰经过一条非树边且不经过树上两点间路径的路径数为： ·若x与y成祖先-孩子关系，假设y是x的祖先，z是y到x方向的第一个节点，则 ans=起点在x的子树里，且终点不在z的子树里的非树边数 ·若x与y不成祖先-孩子关系，则 ans=起点在x的子树里，且终点在y的子树里的非树边数 由于不经过任何非树边也有一解，所以答案要加1 求出DFS序后线段树合并即可解决 ...
【BZOJ3488】[ONTAK2010]Highways 扫描线+树状数组
aodanchui1057的博客
09-17 106
【BZOJ3488】[ONTAK2010]Highways Description 给一棵n个点的树以及m条额外的双向边q次询问，统计满足以下条件的u到v的路径：恰经过一条额外的边不经过树上u到v的路径上的边 Sample Input 9 1 2 2 3 4 2 1 5 5 6 7 5 7 8 9 7 4 2 5 3 4 6 4 8 3 4...
bzoj3488: [ONTAK2010]Highways 扫描线+树状数组
olahiuj的博客
12-05 179
Description 给一棵n个点的树以及m条额外的双向边 q次询问，统计满足以下条件的u到v的路径： 恰经过一条额外的边 不经过树上u到v的路径上的边 n,m&lt;=1e5,q&lt;=5e5 Solution 非常眼熟。之前做过树套树的做法，现在内存卡得紧可以考虑扫描线的做法。 我们把一个矩形查询看成四个前缀和相加减的形式，然后扫描线+树状数组维护前缀和就可以了 这个getup好像每次...
[ONTAK2015] Bajtocja 题解.pdf
最新发布
01-16
【ONTAK2015】Bajtocja 题解主要涉及了图论、并查集和哈希表这三大知识点。这是一个处理图的连通性问题，并且需要高效地进行动态维护。 1. **并查集（Disjoint Set Union, DSU）**： - 在这个题目中，我们需要判断...
[spoj10707]Count on a tree II 解题报告
TA
04-06 2478
一开始不知道这是主席出的神题，不小心点开了。。结果做了1天（想了半天+写了半天）。 我是学莫队的时候在某大神的莫队课件里看到这道题的，他说可以用莫队做。（但这真的算莫队么？） 这道题非常奇怪，就是把 HH的项链 搬到了树上，但是这样就变得好难。。我一开始的想法跟po姐姐的做法差不多，就是把dfs序分成大小为S的块，然后就是O(N3S2+MS)O({N^3\over S^2}+MS)，这样显然块越
[bzoj4066]简单题 解题报告
TA
04-22 1611
也是很久以前奇葩做法搞的题，补个解题报告。大爷的做法：听说是把k-d树写成替罪的或是每n√\sqrt n重建。 傻逼的做法： 我们是理论计算机科学家（当时我弱不会k-d树。。），所以我们需要思考科学的做法。 分块！ 考虑将横坐标分成n√\sqrt n份，纵坐标分成n√\sqrt n份，这样会有n个块。内存首先比较科学了。我们显然需要每插入n√\sqrt n个元素重建。我们对每一行维护前缀和，
[bzoj3065]带插入区间K小值 解题报告
TA
04-23 1531
喜闻乐见的用的很麻烦很傻逼得搞法。。 先用一个块链维护序列，做到O(n√)O(\sqrt n)插入，O(1)O(1)比较两个点在序列中位置的大小。时间复杂度是O(nn√)O(n\sqrt n)。 再用一个块链维护权值，每个块维护按位置排序的序列。查询的时候从小到大枚举每个块，先在块里二分统计块内在查询区间中的个数，然后如果发现答案在这个块里，就直接暴力找到第k小的是哪个。取块大小等于O(nlog
[bzoj3720]Gty的妹子树 解题报告
TA
04-22 1437
大概看了一眼网上的题解，跟块爷一样都写的会被卡的分块。（反正块爷出的题也不会卡自己。。） 这里说一种比较科学的做法。就是用块链维护dfs序。 维护每个节点按dfs序是在哪个块的哪个位置，对每个块维护块中节点的最浅深度、它的下一个块是哪个块，块中节点按dfs序排序的序列，按权值排序的序列。 一开始的时候每B个分一块，最后一块节点数≤B\le B。查询的时候在两边的块暴力，在中间的块里二分，时间复
[hackerrank w25]DAG Queries 解题报告
TA
11-08 1258
又用bitset强上了一道题好开心啊~（然而这题标算似乎就是bitset？）如果暴力的话，可以用bitset，但是空间爆炸；所以我们先解决一下空间问题。 如果考虑对操作分块的话，我们可以只用处理所有节点能否由块内的操作节点抵达，这样首先就可以解决bitset的空间问题！然后一开始我是这样想的： 如果我们可以O(n)O(n)处理出每一个块的操作结束后的aia_i的话，那么就好办了！而这个似乎很容易
[Ahoi2013]作业 解题报告
TA
04-22 1148
很久以前用奇葩做法搞的题。。现在补个解题报告。传统做法： 考虑莫队，就需要我们设计一个O(1)O(1)插入，O(n√)O(\sqrt n)查询的数据结构，显然就需要对权值分块，记每个数出现次数和每个块两问的答案（或者第一问另写个主席树也可以，我比较懒）。莫队的块就分成nm√n\over \sqrt m块。时间复杂度O(mn√+nm−−√)O(m\sqrt n+n\sqrt m)。非常好写，跑的飞快
[JSOI2009]面试的考验 解题报告
TA
04-05 1139
考虑将询问区间按右端点排序。考虑x会与它前面产生贡献的点对，显然，如果i<j<x,ai>aj>axi<j<x,a_i>a_j>a_x，那么(i,x)就是无用的。也就是说我们要求位置 < x且权值大于axa_x的点和小于axa_x的点的两个类似笛卡尔树的序列的东西，而这个在随机数据中显然是O(logn)O(\log n)的。 但是问题是怎么求这个东西呢？一个比较脑残的想法是线段树！就是我们存一棵权值
[bzoj4025]二分图 解题报告
TA
03-25 1081
最近在学lct，拿这道题学了动态图。 法一： 很神的分块（用vector常数太大t了。。） 按时间分块，先将覆盖整个块的边缩起来，然后枚举每一个时间对于块内的边暴力；缩点和暴力都是O(边数目)的。这样的话每个边都会被扫O(T−−√)O(\sqrt T)遍，时间复杂度O(mT−−√)≈6.5∗107O(m\sqrt T)≈6.5*10^7，然后加上我用了vector，常数巨大。。 法二： 很
[bzoj3744]Gty的妹子序列 解题报告
TA
04-26 849
比较显然的做法是用bit维护做到O(nlog−−−√n)O(n\sqrt \log n)。 但是。。作为一名理论计算机科学家傻逼，我们需要O(nn√)O(n\sqrt n)的做法，注意到如果我们把(i,ai)(i,a_i)看成点，实际上要求O(1)O(1)询问一个矩形内点的个数，这个显然可以用可持久化分块来搞，维护每个块内的前缀和和所有块的前缀和——但是空间复杂度是3nn√3n\sqrt n，ML
[scoi2005]王室联邦 解题报告
TA
04-15 693
拿来学了一下树分块。 树分块的要求是把树分成⌈NB⌉\lceil {N\over B} \rceil 块，每一块的每个节点到这个块的lca的之间的节点数不超过3B3B. （好像在很久以前听谁讲过。。）做法是按dfs序出栈或bfs倒序考虑，把当前这个子树的剩余块加到它的父亲上，如果它的父亲上的块已经≥b\ge b就把这个块取出来。这样的话出来的就是若干大小在[b,2b)的块加上一个在[0,b)的块

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值