[题解]AtCoder Beginner Contest 406(ABC406) A~F

因为上线时间有限所以补题和题解都延误了(^^;

写得很急，如有错误/不清晰的点请在评论区提出。

A - Not Acceptable

见代码。时间复杂度$O(1)$。

点击查看代码

#include<bits/stdc++.h>

using namespace std;

int a,b,c,d;

signed main(){

	cin>>a>>b>>c>>d;

	if(a>c) cout<<"Yes\n";

	else if(a==c&&b>d) cout<<"Yes\n";

	else cout<<"No\n";

	return 0;

}

B - Product Calculator

设当前屏幕上的数字为$fac$，要乘的数是$a$，则：

如果$fac\times a\ge 10^k$，则将$fac$置为$1$；否则将$fac$累乘$a$。

$fac\times a$可能会爆long long，可以使用__int128，或者可以转化一下条件：

$fac\times a\ge 10^k\iff a\ge \lceil\frac{10^k}{fac}\rceil$。

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

点击查看代码

#include<bits/stdc++.h>

#define int long long

using namespace std;

int n,k,fac=1;

signed main(){

	cin>>n>>k;

	int t=1;

	for(int i=1;i<=k;i++) t*=10;

	while(n--){

		int a;

		cin>>a;

		if(a>=(t-1)/fac+1) fac=1;

		else fac*=a;

	}

	cout<<fac<<"\n";

	return 0;

}

C - ~

显然峰值和谷值是交替出现的。

我们要找到的就是一个区间，使得这个区间：

恰好有$1$个峰值和$1$个谷值。
峰值在谷值前。
区间头尾均不是峰值/谷值。

定义$nxt[i]$为$a[i\sim n]$中第一个峰/谷的位置。

枚举所有$i$使得$a[i]<a[i+1]$，定义$n_1=nxt[i+1],n_2=nxt[n_1+1],n_3=nxt[n_2+1]$。

如果$n_1,n_2$都存在，则：

如果$n_3$存在，则累加$n_3-n_2$的贡献。
如果$n_3$不存在，则累加$n-n_2$的贡献。

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

点击查看代码

#include<bits/stdc++.h>

#define int long long

#define N 300010

using namespace std;

int n,a[N],b[N],nxt[N],pre[N],ans;

signed main(){

	cin>>n;

	for(int i=1;i<=n;i++) cin>>a[i];

	for(int i=2;i<n;i++) if((a[i]>a[i-1]&&a[i]>a[i+1])||(a[i]<a[i-1]&&a[i]<a[i+1])) b[i]=1;

	for(int i=1;i<=n;i++) pre[i]=(b[i]?i:pre[i-1]);

	for(int i=n;i>=1;i--) nxt[i]=(b[i]?i:nxt[i+1]);

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

		if(a[i]<a[i+1]){

			int n1=nxt[i+1],n2=nxt[n1+1],n3=nxt[n2+1];

			if(n1&&n2) ans+=(n3?n3-n2:n-n2);

		}

	}

	cout<<ans<<"\n";

	return 0;

}

D - Garbage Removal

赛时思路（稍有修改）：为行和列各开一个set存里面的垃圾的坐标$(x,y)$，每处理一个行的操作，就遍历该行的垃圾，并在其所在列中删除它。列同理。

为了方便查找，代码将$(x,y)$压成一个整数了。

时间复杂度$O(n+m+k+q)$。
题解思路：同一行/列的询问，从第$2$次开始就是$0$不变了。所以为行和列各开一个桶来统计该行/列是否被查询过，如果查询过直接输出$0$，否则遍历该行/列的垃圾，如果没有被清除，则产生$1$的贡献，并标记该垃圾已被清除。

由于每行、每列的垃圾最多被遍历$1$次，所以时间复杂度为$O(n+m+k+q)$。

赛时思路

#include<bits/stdc++.h>

#define int long long

#define N 200010

using namespace std;

int n,m,k,q;

unordered_map<int> hang[N],lie[N];

signed main(){

	cin>>n>>m>>k;

	while(k--){

		int x,y;

		cin>>x>>y;

		hang[x].insert(x*N+y),lie[y].insert(x*N+y);

	}

	cin>>q;

	while(q--){

		int op,x;

		cin>>op>>x;

		if(op==1){

			cout<<hang[x].size()<<"\n";

			for(auto i:hang[x]) lie[i%N].erase(i);

			hang[x].clear();

		}else{

			cout<<lie[x].size()<<"\n";

			for(auto i:lie[x]) hang[i/N].erase(i);

			lie[x].clear();

		}

	}

	return 0;

}

题解代码见https://atcoder.jp/contests/abc406/editorial/13053。

E - Popcount Sum 3

数位dp，下文使用DFS实现，规定最低位为$1$。

这些是我的数位dp笔记：上篇、下篇、EX（未发布）。

由于要对满足条件的数求和，所以如果我们搜索到最后再统计贡献的话，将很难记忆化。因为就算两个搜索的状态“当前的数位”和“到目前为止$1$的个数”都相同，由于已经填好的数位不同，两个状态的答案也一定不同。但是这两个状态往后填写的情况是完全相同的。

所以我们不妨修改策略，让每个状态仅统计：

$sum$：其搜索子树中所有答案 从当前数位到最低位的子串 之和。
$cnt$：其搜索子树中的答案个数。

$sum$的定义说明每个状态仅需关注它后面所填的值，不需要管之前填写的内容。与CF1073E Segment Sum（题解）这道题非常相似，可以类比一下两题的做法。

假设当前填到第$pos$位，则有转移：

\[\large sum[u]=\sum\limits_{i\in son[u],第pos位填w} sum[i]+w\times cnt[i]\times 2^{pos-1}
\]

最后输出$sum[root]$即可。

可以使用$f[pos][pc]$来记忆化，其中$pc$是填到目前$1$的个数。

时间复杂度$O(|\Sigma|\times \lg n\times k)$。其中$|\Sigma|=2$，表示字符集大小。

点击查看代码

#include<bits/stdc++.h>

#define int long long

#define mod 998244353

#define K 70

using namespace std;

int t,n,k,a[K];

bitset<K> fv[K];

pair<int,int> f[K][K];

//first表示cnt，second表示sum

pair<int,int> dfs(int pos,bool limit,int pc){

	if(pc>k) return {0,0};

	if(!pos) return {(pc==k),0};

	if(!limit&&fv[pos][pc]) return f[pos][pc];

	int rig=limit?a[pos]:1;

	pair<int,int> ans{0,0};

	for(int i=0;i<=rig;i++){

		auto res=dfs(pos-1,limit&&i==rig,pc+i);

		(ans.second+=res.second)%=mod;

		(ans.second+=i*(1ll<<(pos-1))%mod*res.first%mod)%=mod;

		(ans.first+=res.first)%=mod;

	}

	if(!limit) fv[pos][pc]=1,f[pos][pc]=ans;

	return ans;

}

int solve(int x){

	for(int i=0;i<K;i++) fv[i]=0;

	int len=0;

	while(x) a[++len]=x&1,x>>=1;

	return dfs(len,1,0).second;

}

signed main(){

	cin>>t;

	while(t--){

		cin>>n>>k;

		cout<<solve(n)<<"\n";

	}

	return 0;

}

F - Compare Tree Weights

核心操作在于单点修改权值以及查询子树和。

我们按DFS序给每个节点重新编号，容易发现一个子树中节点的DFS序是连续的，所以可以放到树状数组/线段树上操作。

其实就是把树剖模板题里“子树操作”弱化后搬到这来了。

代码的时间复杂度$O((n+q)\log n)$，树状数组初始化优化一下可以做到$O(n+q\log n)$。

点击查看代码

#include<bits/stdc++.h>

#define N 300010

using namespace std;

int n,q,tim,dfn[N],siz[N],u[N],v[N],dep[N];

vector<int> G[N];

inline int lowbit(int x){return x&-x;}

struct BIT{

	int s[N];

	void add(int x,int k){while(x<=n) s[x]+=k,x+=lowbit(x);}

	int query(int x){int ans=0;while(x) ans+=s[x],x-=lowbit(x);return ans;}

	int query(int l,int r){return query(r)-query(l-1);}

}bit;

void dfs(int u,int fa){

	dfn[u]=++tim,siz[u]=1,dep[u]=dep[fa]+1;

	for(int i:G[u]) if(i!=fa) dfs(i,u),siz[u]+=siz[i];

}

void add(int u,int v){G[u].emplace_back(v);}

signed main(){

	cin>>n;

	for(int i=1;i<n;i++) cin>>u[i]>>v[i],add(u[i],v[i]),add(v[i],u[i]);

	dfs(1,0);

	for(int i=1;i<n;i++) if(dep[u[i]]<dep[v[i]]) swap(u[i],v[i]);

	for(int i=1;i<=n;i++) bit.add(i,1);

	cin>>q;

	while(q--){

		int o,x,y;

		cin>>o;

		if(o==1){

			cin>>x>>y,bit.add(dfn[x],y);

		}else{

			cin>>x;

			int s=bit.query(n),t=bit.query(dfn[u[x]],dfn[u[x]]+siz[u[x]]-1);

			cout<<abs(2*t-s)<<"\n";

		}

	}

	return 0;

}