CF466E Information Graph 题解

最新推荐文章于 2024-10-14 09:08:48 发布
最新推荐文章于 2024-10-14 09:08:48 发布
阅读量50 收藏
点赞数
文章标签： 算法

1|0题目链接

Luogu

Codeforces

2|0题意简述

某公司中有 \(n\) 名员工。为方便起见，将这些员工从 1 至 \(n\) 编号。起初，员工之间相互独立。接下来，会有以下 \(m\) 次操作：

  1. 员工 \(y\) 成为员工 \(x\) 的上司。保证此前 \(x\) 没有上司。

  2. 员工 \(x\) 拿到一份文件并签字，随后交给他的上司。他的上司签字后，再交给更上一级。依此类推，直到文件传递到的那个人没有上司为止。

  3. 询问员工 \(x\) 是否在第 \(i\) 件文件上签过字。文件编号为上一件文件的编号再加 1，第一件文件的编号为 1。如果是，输出 YES，否则输出 NO。

3|0解法说明

显然，我们可以将员工之间的关系看作森林，将每个员工看作一个节点，其与上司的关系看作一条边。之所以不是一棵树，是因为在 \(m\) 次操作中，有些人可能并没有被指定上司，所以员工之间的关系很可能并不是一棵树而是森林。

通过观察题面可以发现，一个员工在成为另一个员工的上司后，就不会再有更改了。由于在线操作过于麻烦，我们可以考虑离线。

具体离线方法如下：

  • 对于操作 1，直接连边即可，不过这里还要在线维护一个并查集；

  • 对于操作 2，分别记下第一个和最后一个对文件签字的员工，后者就是前者所在的连通块的根，利用并查集查找；

  • 对于操作 3，分别记下员工编号及文件编号，离线回答。

接下来分析如何回答询问。可以发现，如果询问的员工 \(x\) 在 最开始看到文件 \(i\) 的员工与最后看到文件 \(i\) 的员工之间的链上，那么 \(x\) 就看过文件。所以，问题就被转化为了判断 \(x\) 是否在这条链上。

考虑如何判断。

设 \(st\) 为链的起始点，\(ed\) 为截止点，可推得如 \(x\) 在链上，则 \(\text{lca}(x,st) = x\) 且 \(\text{lca}(x,ed) = ed\)，维护一个 LCA 即可求解。我这里用的是树剖求 LCA，倍增也可以。

还有一些细节需要注意。由于员工之间的关系是森林而非一棵树，所以我们在预处理树剖时应枚举每个点，如果该点是其所属的连通块的根，就对其进行一次预处理，且回答询问时应首先判断 \(x\) 与 \(st\)、\(ed\) 是否在同一连通块内，如果不在直接输出 NO，否则再执行下一步操作。

剩余细节详见下面代码中的注释。

4|0通过代码

 

    
    

     
     

      
      
       
       
       
       #include<bits/stdc++.h>

       
       
       
       using 
       
       namespace 
       
       std;

       
       
       
       #define int long long

       
       
       
       #define PII pair<int,int>

       
       
       
       #define mp make_pair

       
       
       
       const 
       
       int N=
       
       1e5+
       
       10;

       
       

       
       
       
       namespace IO{

       
           
       
       //快读 

       
           
       
       inline int read(){

       
               
       
       int x=
       
       0,f=
       
       1;

       
               
       
       char ch=getchar();

       
               
       
       while(ch<
       
       '0'||ch>
       
       '9'){

       
                   
       
       if(ch==
       
       '-'){

       
                       f=
       
       -1;

       
                   }

       
                   ch=getchar();

       
               }

       
               
       
       while(ch>=
       
       '0'&&ch<=
       
       '9'){

       
                   x=(x<<
       
       1)+(x<<
       
       3)+(ch^
       
       48);

       
                   ch=getchar();

       
               }

       
               
       
       return x*f;

       
           }

       
           

       
           
       
       //快写 

       
           
       
       inline void write(int x){

       
               
       
       if(x<
       
       0){

       
                   
       
       putchar(
       
       '-');

       
                   x=-x;

       
               }

       
               
       
       if(x>
       
       9){

       
                   write(x/
       
       10);

       
               }

       
               
       
       putchar(x%
       
       10+
       
       '0');

       
           }

       
       } 

       
       

       
       
       
       using 
       
       namespace IO;

       
       

       
       
       
       namespace code{

       
           
       
       //链式前向星存图 

       
           
       
       int head[N],tot;

       
           

       
           
       
       struct node{

       
               
       
       int ver,next;

       
           }t[N<<
       
       1];

       
           

       
           
       
       void add(int x,int y){

       
               t[++tot].ver=y,t[tot].next=head[x],head[x]=tot;

       
           }

       
           

       
           
       
       //并查集

       
           
       
       int fa[N];

       
           

       
           
       
       int getfa(int x){

       
               
       
       if(fa[x]==x){

       
                   
       
       return x;

       
               }

       
               
       
       return fa[x]=getfa(fa[x]);

       
           } 

       
           

       
           
       
       //树链剖分 

       
           
       
       int fat[N],size[N],son[N],deep[N],top[N];

       
           

       
           
       
       void dfs1(int x){

       
               size[x]=
       
       1;

       
               
       
       int maxson=
       
       -1;

       
               
       
       for(
       
       int i=head[x];i;i=t[i].next){

       
                   
       
       int y=t[i].ver;

       
                   
       
       if(y==fat[x]){

       
                       
       
       continue;

       
                   } 

       
                   fat[y]=x;

       
                   deep[y]=deep[x]+
       
       1;

       
                   dfs1(y);

       
                   
       
       if(size[y]>maxson){

       
                       maxson=size[y];

       
                       son[x]=y;

       
                   }

       
                   size[x]+=size[y];

       
               }

       
           }

       
           

       
           
       
       void dfs2(int x,int from){

       
               top[x]=from;

       
               
       
       if(!son[x]){

       
                   
       
       return;

       
               }

       
               dfs2(son[x],from);

       
               
       
       for(
       
       int i=head[x];i;i=t[i].next){

       
                   
       
       int y=t[i].ver;

       
                   
       
       if(y==son[x]||y==fat[x]){

       
                       
       
       continue;

       
                   }

       
                   dfs2(y,y);

       
               }

       
           }

       
           

       
           
       
       //求LCA

       
           
       
       int lca(int x,int y){

       
               
       
       while(top[x]!=top[y]){

       
                   
       
       if(deep[top[x]]<deep[top[y]]){

       
                       swap(x,y);

       
                   }

       
                   x=fat[top[x]];

       
               }

       
               
       
       if(deep[x]<deep[y]){

       
                   
       
       return x;

       
               }

       
               
       
       return y;

       
           }

       
           

       
           
       
       //主程序 

       
           
       
       int n,m,f_tot,q_tot;

       
           PII file[N],query[N];

       
           

       
           
       
       void solve(){

       
               n=read(),m=read();

       
               
       
       for(
       
       int i=
       
       1;i<=n;i++){
       
       //并查集预处理 

       
                   fa[i]=i;

       
               }

       
               
       
       for(
       
       int i=
       
       1;i<=m;i++){
       
       //离线处理 

       
                   
       
       int op=read();

       
                   
       
       if(op==
       
       1){

       
                       
       
       int x=read(),y=read();

       
                       add(y,x);
       
       //单向边 

       
                       fa[x]=getfa(y);
       
       //在线维护并查集 

       
                   }
       
       else 
       
       if(op==
       
       2){

       
                       
       
       int x=read();

       
                       file[++f_tot]=mp(x,getfa(x));

       
                   }
       
       else{

       
                       
       
       int x=read(),y=read();

       
                       query[++q_tot]=mp(x,y);

       
                   }

       
               }

       
               
       
       for(
       
       int i=
       
       1;i<=n;i++){
       
       //枚举所有点 

       
                   
       
       if(getfa(i)==i){
       
       //判断是否为所在连通块的根 

       
                       deep[i]=
       
       1;
       
       //树剖预处理 

       
                       fat[i]=i;

       
                       dfs1(i);

       
                       dfs2(i,i);

       
                   }

       
               }

       
               
       
       for(
       
       int i=
       
       1;i<=q_tot;i++){

       
                   
       
       int x=query[i].first,y=query[i].second,st=file[y].first,ed=file[y].second;

       
                   
       
       if(getfa(x)!=getfa(st)){
       
       //是否在同一个连通块 

       
                       
       
       printf(
       
       "NO\n");

       
                       
       
       continue;

       
                   }

       
                   
       
       if(lca(x,st)==x&&lca(x,ed)==ed){
       
       //判断 

       
                       
       
       printf(
       
       "YES\n");

       
                   }
       
       else{

       
                       
       
       printf(
       
       "NO\n");

       
                   }

       
               }

       
           }

       
       }

       
       

       
       
       
       using 
       
       namespace code;

       
       

       
       
       
       signed main(){

       
           solve();

       
           
       
       return 
       
       0;

       
       }

__EOF__

本文作者： Alexxtl
本文链接： https://www.cnblogs.com/Alexxtl/p/18312437.html
关于博主：I am a good person
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角 【推荐】一下。您的鼓励是博主的最大动力！
原创作者: Alexxtl 转载于: https://www.cnblogs.com/Alexxtl/p/18312437
放心选·独孤评测
关注
CodeForces 466E Information Graph --树形转线性+并查集
weixin_30835933的博客
01-17 98
题意：有三种操作： 1.新增一条边从y连向x，此前x没有父节点 2.x接到一份文件，（文件标号逐次递增），然后将这份文件一路上溯，让所有上溯的节点都接到这份文件 3.查询某个节点x是否接到过文件F 解法： 首先要知道一个性质，节点u在v的上溯路径上的话要满足： L[u]<=L[v] && R[u] >= R[v] （先进后出） 先将所有的边都读入，...
CF 题目集锦 PART 5 #266 div 2 E
阿蒋的专栏
09-16 1400
【原题】 E. Information Graph time limit per test 1 second memory limit per test 512 megabytes input standard input output standard output There are n employees worki
【CodeForces】CF103B Cthulhu
数学、算法爱好者的博客
06-21 213
https://www.luogu.com.cn/problem/CF103B题面翻译： 很久很久以前的一天，一位美男子来到海边，海上狂风大作。美男子希望在海中找到美人鱼，但是很不幸他只找到了章鱼怪。然而，在世界的另一端，人们正在积极的收集怪物的行为信息，以便研制出强大的武器来对付章鱼怪。由于地震的多发，以及恶劣的天气，使得我们的卫星不能很好的定位怪物，从而不能很好的命中目标。第一次射击的分析结果会反映在一张由nnn个点和mmm条边组成的无向图上。现在让我们来确定这张图是不是可以被认为是章鱼怪。为了简单起见
CF实日录
Hugokung的博客
07-16 195
C. Playlist time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output You have a playlist consisting ofnnsongs. Theii-th song is charact...
Educational Codeforces Round 22 补题 CF 813 A-F
weixin_30765577的博客
06-06 299
AThe Contest 直接粗暴贪心 略过 #include<bits/stdc++.h> using namespace std; int main() {//freopen("t.txt","r",stdin); long long int n,sum=0,k; scanf("%lld",&n); for(int i=0;i<n;i++...
Codeforces Round #363 (Div. 2) 题解报告
queuelovestack的专栏
07-20 1488
Codeforces Round #363 (Div. 2) 题解报告
CF EDU 22 F. Bipartite Checking （时间分治线段树+可撤销并查集+二分图判定）
hello_world_banni的博客
11-03 159
CF EDU 22 F. Bipartite Checking ∗2500*2500∗2500 题意： You are given an undirected graph consisting of nnn vertices. Initially there are no edges in the graph. Also you are given qqq queries, each query either adds one undirected edge to the graph or removes
CF453C Little Pony and Summer Sun Celebration （DFS）
weixin_34293902的博客
08-24 111
http://codeforces.com/contest/456 CF454E Codeforces Round #259 (Div. 1) C Codeforces Round #259 (Div. 2) E Little Pony and Summer Sun Celebration time limit per test 1 second memory ...
Codeforces 883G Orientation of Edges(BFS+MAP)
ZhaoYi1222的博客
10-23 463
原题链接Problem DescriptionVasya has a graph containing both directed (oriented) and undirected (non-oriented) edges. There can be multiple edges between a pair of vertices.Vasya has picked a vertex s from
java-leetcode题解之Is Graph Bipartite.java
10-09
java java_leetcode题解之Is Graph Bipartite.java
python-leetcode题解之133-Clone-Graph
09-06
python python_leetcode题解之133_Clone_Graph
D - 8 Puzzle on Graph题解
m0_58178876的博客
10-24 2933
atcoder上的一题，感觉挺有意思的就写一下题解，别问我为什么当时没做出来，因为我C题（暴力枚举判断三角形）写爆了，*****，掉大分。 题目链接：D - 8 Puzzle on Graph (atcoder.jp) 题目大意：就是最强大脑里的数字华容道的改版，给你一个3*3的方格阵，有一个空着的，给出初始状态，但是这些方块不能随意移动，他们只能通过给定的凹槽间的边来移动，求出还原成标准状态（数字按大小排好序，如图二，只不过改成了3*3的）最少的移动步数 其实翻译一下就是一张无向图有且仅有.
【文档智能】文本文字识别、公式识别、表格文字识别核心算法及思路及实践-DBNet、CRNN、TrOCR
余俊晖，NLP炼丹师，目前专注自然语言处理领域研究。曾获得国内外自然语言处理算法竞赛TOP奖项近二十项。
10-13 1266
OCR技术作为文档智能解析链路中的核心组件之一，贯穿整个技术链路，包括：文字识别、表格文字识别、公式识别，参看下面这张架构图：前期介绍了很多关于文档智能解析相关核心技术及思路，本着连载的目的，本次迎来介绍整个链路中的最后一块拼图-OCR。本文简要介绍OCR常见落地的算法模型-DBNet、CRNN，并基于这两个模型，简单介绍文字识别在表格识别中参与的角色；并且额外介绍TrOCR这个端到端的模型，基于这个模型引入公式识别解析的思路及微调方法。
在顺序结构和链式结构的线性表上实现顺序检索算法
m0_56332819的博客
10-13 216
在顺序结构和链式结构的线性表上实现顺序检索算法，C语言
Python 使用 Jarvis 算法或包装的凸包（Convex Hull using Jarvis’ Algorithm or Wrapping）
最新发布
csdn_aspnet的专栏
10-14 1152
例如，当输入 (0, 3), (0, 0), (0, 1), (3, 0), (3, 3) 时，它产生 (0, 3) (0, 0) (3, 0) (3, 3) 的输出；当输入 (0, 3), (0, 1), (0, 0), (3, 0), (3, 3) 时，输出为 (0, 3) (0, 1) (0, 0) (3, 0) (3, 3)。下一个点被选为在逆时针方向上领先于所有其他点的点，即，如果对于任何其他点 r，我们有“orientation(p, q, r) = 逆时针”，则下一个点是 q。
力扣10.13
qq_40052678的博客
10-13 361
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
c语言练习题2(字符串和函数的使用)
m0_74859128的博客
10-10 365
回文函数用于判断一个给定的字符串是否为回文。输入是一个字符数组（字符串），输出是一个布尔值，表示该字符串是否为回文。编写一个 C 语言程序，计算两个整数在二进制表示中有多少位不同。2. 比较这两个整数在二进制表示中的每一位（共32位）是否不同。1. 提示用户输入两个整数。3. 统计不同的位的数量。4. 输出不同的位数。
Spark GraphX实战解析
"Spark GraphX in Action 是一本由Michael S. Malak和Robin East合作编写的书籍，由Manning出版社出版。这本书详细介绍了Apache Spark的GraphX组件，它是一个用于处理图形数据的API，适用于大数据分析和图计算。通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值