CodeForce #736 C

昨天补题，写了一个看起来是图论却不那么图论的图论题

题目链接：贵族

题目大意：
这里有N个贵族编号从1到N，编号为i的贵族据有i点权利，最初有M个“关系”，每一个a，b之间的关系都是相互的。
当某个贵族满足：至少有一个朋友并且他所有的朋友权力都大于他时，这个贵族便被定义为是弱势的。
我们有以下三种操作：

1. 在u、v之间添加一个“关系”

2. 将u、v之间的“关系”去掉

3. 为以下的程序计算答案

程序描述：杀死所有的弱势贵族，并且删除所有与他相关的“关系”。
于是，会有新的贵族成为弱势贵族。
程序会一直执行到不存在弱势贵族为止。
在程序结束后，你需要计算最后存活下来的贵族的数量。
PS:每次程序执行之前，所有的贵族都是活着的。

输入：
第一行输入两个整数n,m有(1<=n,m<=2e5)，代表贵族的人数和初始关系个数
接下来m行输入两个整数u，v(1<=u,v<=n,u!=v)来描述关系。没有重复的关系出现
接下来一行输入一个整数q(1<=q<=2e5)表示操作次数
接下来q行，操作以下面的方式输入：

• 1 u v (1<=u,v<=n,u!=v)表示在u,v之间添加一个“关系”
• 2 u v (1<=u,v<=n,u!=v)表示删除u,v之间的“关系”
• 3 输出程序执行完毕的结果

输出 ：
对于每一个查询操作“3”，输出一行程序执行的结果

Examples:

input

4 3
2 1
1 3
3 4
4
3
1 2 3
2 3 1
3

output

2
1

input:

4 3
2 3
3 4
4 1
1
3

output

1

解题思路：
为什么说这个题是个看起来是图论却不那么图论的图论题 呢？
因为这个题完全不需要建图。。。。

请不要过于纠结于题目中所提到的关系都是相互的，题目引导我们建立无向图，但其实不需要，因为每次杀人都是从同一个朋友圈中编号最小的开始杀。
让我们仔细理解一下这句话：永远只可能杀完小号才杀大号。
因此，我们只需要从编号较小的贵族向编号较大的贵族连边。

那为什么说不需要建图呢？
因为每一次程序执行完，每个独立的朋友圈中只会剩下一个贵族，也就是说，我们只需要判断哪些贵族会坚持到最后就好了。

如何判断呢？
因为每一次连边都是从小号连到大号，那么很容易可以知道，只要小号连接到了大号，那么小号一定会死，我们可以将每一次连边想象成一个只有两个人的朋友圈，如果直接执行程序，那么最后剩下的只会是编号更大的贵族。
因此，只要某一个贵族从来没有向任何一个编号更大的贵族连过边，那么这个贵族一定是安全的！。

那么我们很容易就能够想到，利用一个out[i]数组记录编号为i的贵族是否向外连过边即可（即记录每个点的出度，出度为0的贵族一定能存活）。

这个时候我们就可以将写好的代码提交了！

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=200010;
int n,m;
int u,v;
int q;//操作次数
int x;
int out[N];//出度数组
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        scanf("%d%d",&u,&v);
        if(u>v)out[v]++;
        else out[u]++;
    }
    scanf("%d",&q);
    while(q--){
        scanf("%d",&x);
        if(x==1){
            scanf("%d%d",&u,&v);
            if(u>v)out[v]++;
            else out[u]++;
        }
        else if(x==2){
            scanf("%d%d",&u,&v);
            if(u>v)out[v]--;
            else out[u]--;
        }
        else{
            int res=0;
            for(int i=1;i<=n;i++){
                if(!out[i])res++;
            }
            printf("%d\n",res);
        }
    }
    return 0;
}

于是乎，我们在第4个样例就会T掉QAQ。。。。。

这是为什么呢？
我们仔细看看数据范围：1<=n<=2e5,1<=q<=2e5
哦豁
如果我们直接拿out数组记录出度的话，由于复杂度是O（n*q），最坏情况下可能达到4e10
显然会T
都是不看数据范围惹的祸

那么如何改进呢？
显然我们只能把out数组删去了，让程序复杂度降到O（q+n）
删去out数组后该怎么得到答案呢？
我们会发现，只有out数组对应位为0时，才会对答案进行累加，那么我们可以在加边删边的时候在线处理答案。
具体如何实现请看代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=200010;
int n,m;
int u,v;
int q,x;
int out[N];
int ans;
int main(){
    scanf("%d%d",&n,&m);
    ans=n;//初始化答案为n，表示一个人都还没死
    for(int i=1;i<=m;i++){
        scanf("%d%d",&u,&v);
        if(out[u>v?v:u]==0&&++out[u>v?v:u]>0)ans--;//只有当out数组从0变成1时才会令ans--，毕竟一个人关系再多也不可能死两次对吧
        else ++out[u>v?v:u];
    }
    scanf("%d",&q);
    while(q--){
        scanf("%d",&x);
        if(x==1){
            scanf("%d%d",&u,&v);
            if(out[u>v?v:u]==0&&++out[u>v?v:u]>0)ans--;//与初始化时一样的道理
            else ++out[u>v?v:u];
        }
        else if(x==2){
            scanf("%d%d",&u,&v);
            if(--out[u>v?v:u]==0)ans++;//只有当一个人身上的关系完全清空才可以不死，令ans++
        }
        else{
            printf("%d\n",ans);
        }
    }
    return 0;
}

That’s All