ABC392

终于进前一千了。

A - Shuffled Equation

人话：给定三个数 $a,b,c$，判断是否存在两个数乘积为第三个数。

数很小，if 判断一下，long long 也不用开。

点击查看代码

#include <iostream>
#include <cstdio>
using namespace std;
int a,b,c;
int main(){
	cin>>a>>b>>c;
	if(a*b==c)cout<<"Yes"<<endl;
	else if(b*c==a)cout<<"Yes"<<endl;
	else if(c*a==b)cout<<"Yes"<<endl;
	else cout<<"No"<<endl;
} 

时间复杂度 $O(1)$。

B - Who is Missing?

注意到值域很小，我们开一个桶。如果 $i$ 出现过，则 $f_i$ 为 $1$，反之为 $0$。

然后按照 $1\sim n$ 的顺序检查那个桶里没数就行。

点击查看代码

#include <iostream>
#include <cstdio>
using namespace std;
int n,m,x,t[1005],cnt;
int main(){
	cin>>n>>m;
	for(int i=1;i<=m;i++)cin>>x,t[x]++;
	for(int i=1;i<=n;i++)if(!t[i])cnt++;
	cout<<cnt<<endl;
	for(int i=1;i<=n;i++)if(!t[i])cout<<i<<" ";
	return 0;
} 

时间复杂度 $O(n)$。

C - Bib

挺绕的。

每个人有三个属性，编号，牌子（也就是 $p_i$），看的人的编号（也就是 $q_i$）。

假设 $s_i$ 表示牌子上的数位 $i$ 的人的编号。这个可以预处理建立映射关系。

那么根据定义，牌子为 $i$ 的人编号为 $s_i$，看的人的编号为 $q_{s_i}$，看的人挂的牌子为 $p_{q_{s_i}}$。

主要是搞清楚编号，牌子，看的人之间的关系即可。

点击查看代码

#include <iostream>
#include <cstdio>
using namespace std;
const int N=3e5+10;
int n,p[N],q[N],s[N];
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d",q+i); 
	}
	for(int i=1;i<=n;i++){
		scanf("%d",s+i);
		p[s[i]]=i;
	}
	for(int i=1;i<=n;i++){
		printf("%d ",s[q[p[i]]]);
	}
	return 0;
} 

时间复杂度 $O(n)$。

D - Doubles

咋还卡人精度呢？

先思考暴力，枚举两个骰子 $i,j$，枚举摇出来的数 $x$，则答案就是：

$$\sum _{x=1}^{\mathrm{\infty }}{\displaystyle \frac{cn{t}_{i,x}}{k_i}}\times {\displaystyle \frac{cn{t}_{j,x}}{k_j}}$$

$${\displaystyle \frac{\sum _{x=1}^{\mathrm{\infty }}cn{t}_{i,x}\times cn{t}_{j,x}}{k_i{k}_j}}$$

$cn{t}_{i,j}$ 表示骰子 $i$ 有多少个面是 $j$，上面的式子根据乘法原理和加法原理易得。

暴力会超时，注意值域很小，我们先枚举 $i$，然后开一个桶 $t_j$ 表示骰子 $i$ 有多少个面为 $j$。

接着我们枚举每一个 $j<i$，分别计算 $i,j$ 的答案，具体做法是遍历 $j$ 骰子的每一个面 $x$，然后让答案 $ans$ 加上 $t_x$。最后 $\frac{ans}{k_i{k}_j}$。

枚举 $i$ 是 $O(n)$ 的，枚举每一个骰子 $i$ 的面是 $K_i$，枚举 $j$，枚举 $j$ 骰子的每一个面可以看成一个整体，是 $O(S-K_i)$ 的，其中 $S=\sum K_i$，意思是最多会将除了骰子 $i$ 以外其他所有骰子的所有面都遍历一遍。

容易发现后两步合起来是 $O(S)$。这样做复杂度均摊下来是正确的。

点击查看代码

#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
const int N=1e5+10;
vector<int>v[105];
int n;
long long k[105],cnt[N];
long double res,ans;
long double fmax(long double a,long double b){
	return a<b?b:a;
}
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%lld",k+i);
		for(int j=1,x;j<=k[i];j++){
			scanf("%d",&x);
			v[i].push_back(x);
		}
	}
	for(int i=2;i<=n;i++){
		for(auto u:v[i])cnt[u]++;
		for(int j=1;j<i;j++){
			res=0;
			for(auto u:v[j])res=(double)(res+cnt[u]);
			res=(long double)(res/(k[i]*k[j]));
			ans=max(ans,res); 
		}
		for(auto u:v[i])cnt[u]--;
	}
	printf("%.12LF\n",ans);
	return 0;
}

时间复杂度 $O(nS)$。

E - Cables and Servers

小清新题。

注意到 $M\ge N-1$，也就是说无论如何我们也可以给所有边的两个端点重新编号，让他联通。

我们先把原图建出来，这样的图是若干个不连通的图。在原图中，有一些边是无关紧要的，去掉这一条边对原图联通性没有影响。我们可以用这些边来连接其他的联通块。

我们思考这样一个过程：划分联通块，然后找出每个联通块有多少个无用的边，统计当前那个联通块 $u$ 无用边最多，那个联通块 $v$ 无用边次多，将 $u$ 内的一条无用边的一个端点改到 $v$ 上的端点，此时 $u,v$ 就被合并了，$v$ 的无用边也变成了 $u$ 的无用边。因为 $M\ge N-1$，所以除了这个图仅剩一个联通块的情况，无论何时都有无用边。

容易发现，此时 $u,v$ 合并后的联通块又成为了无用边最多的联通块，假设有 $k$ 个联通块，我们按照每个联通块内部无用边多少排序，然后依次将 $2\sim k$ 的联通块和 $1$ 合并，这个算法就是正确的，容易发现，这样的操作此时为 $k-1$。

考虑构造方案，我们把每个联通块排好序后，将每个联通块内的无用边按照同样顺序放进数组里，然后从前往后一条一条边的用即可。

点击查看代码

#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
const int N=2e5+10;
int n,m,a[N],b[N],f[N],rt[N],k,rest[N],p,mk[N];
vector<int>vec[N];
int found(int x){
	return f[x]==x?x:f[x]=found(f[x]); 
}
bool cmp(int a,int b){
	return vec[a].size()>vec[b].size();
} 
int main(){
	scanf("%d %d",&n,&m);
	for(int i=1;i<=n;i++)f[i]=i;
	for(int i=1;i<=m;i++){
		scanf("%d %d",a+i,b+i);
		int u=found(a[i]);
		int v=found(b[i]);
		if(u!=v)f[u]=v;
		else mk[i]=1;
	}
	for(int i=1;i<=m;i++)if(mk[i])vec[found(a[i])].push_back(i);
	for(int i=1;i<=n;i++)if(found(i)==i)rt[++k]=i;
	printf("%d\n",k-1);
	sort(rt+1,rt+1+k,cmp);
	for(int i=1;i<=k;i++)for(auto j:vec[rt[i]])rest[++p]=j;
	for(int i=2;i<=k;i++){
		printf("%d %d %d\n",rest[i-1],a[rest[i-1]],rt[i]);
	}
	return 0;
}

时间复杂度 $O(n\log n)$。

F - Insert

平衡树板子，蚌埠住了。

考虑无旋 treap（FHQ treap），每个节点上维护一个权值，和子树的大小，插入第 $i$ 个数时，假设这个数排名为 $k$。split 时，将平衡树分成两颗大小分别为 $k-1$ 和 $i-k$ 两颗平衡树，merge 时把新建的节点夹在中间合并即可，时间复杂度 $O(n\log n)$。

点击查看代码

#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std;
const int N=5e5+10;
int tot,root,n;
struct node{
    int l,r,size,dat,val;
}a[N];
int New(int s){
    a[++tot].val=s;
    a[tot].size=1;
    a[tot].dat=rand();
    return tot;
}
void update(int p){
    a[p].size=a[a[p].l].size+a[a[p].r].size+1;
}
void split(int p,int k,int &x,int &y){
    if(!p)return x=y=0,void();
    else if(a[a[p].l].size+1<=k)split(a[p].r,k-a[a[p].l].size-1,a[x=p].r,y);
    else split(a[p].l,k,x,a[y=p].l);
    update(p);
}
int merge(int x,int y){
    if(!x||!y)return x+y;
    if(a[x].dat>a[y].dat)return a[x].r=merge(a[x].r,y),update(x),x;
    else return a[y].l=merge(x,a[y].l),update(y),y;
}
void insert(int s,int k){
    int x=0,y=0;
    split(root,k-1,x,y);
    root=merge(merge(x,New(s)),y);
}
void print(int p){
	if(!p)return;
	print(a[p].l);
	printf("%d ",a[p].val);
	print(a[p].r);
	return;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
    	int p;
    	scanf("%d",&p);
    	insert(i,p);
	}
	print(root);
    return 0;
}

多的可以去看平衡树模板。

G - Fine Triplets

好好好，都会 FFT/NTT 是吧。

首先 $B-A=C-B$ 可以写作 $2B=A+C$，所以我们只需要求出有多少个数对 $(A,C)$ 和为 $2B$。

我们不妨开一个桶 $t$，$t_x$ 表示 $S$ 中 $x$ 的出现次数。记 $m=2B$，上面说的这个问题答案即为 $\sum _{i=1}^{m-1}{t}_i{t}_{m-i}$ 的一半（因为求得是无序数对）。

这个玩意不就是一个卷积吗，FFT/NTT 可以 $O(n\log n)$ 求出来。

？这不是卷积模板吗。

好吧，我不会卷积。。。