牛客周赛 Round 35（A,B,C,D,E,F,G）

这场简单，甚至赛时90分钟不到就AK了。比赛链接，队友题解友链

刚入住学校监狱，很不适应，最近难受的要死，加上最近几场CF打的都不顺利，san值要爆掉了，只能慢慢补题了。

这场C是个滑动窗口，D是贪心，E是有点麻烦的构造，FG是数论。

---

A 小红的字符串切割

思路：

记录一下字符串长度，然后从中间拆开。

code：

#include 
#include 
#include 
using namespace std;

string s;

int main(){
	cin>>s;
	cout<<s.substr(0,s.length()/2)<<endl<<s.substr(s.length()/2);
	return 0;
}

---

B 小红的数组分配

思路：

统计一下每个数字出现的次数，然后两个两个拿走，如果有一种数字剩下了奇数个，就说明这种数字不能平分给两个数组，直接返回-1。

code：

#include 
#include 
#include 
using namespace std;
const int maxn=1e5+5;

int n,a[maxn];
map<int,int> mp;

int main(){
	cin>>n;
	for(int i=1,t;i<=2*n;i++){
		cin>>t;
		mp[t]++;
	}
	for(int i=1;i<=n;i++){
		if(mp.begin()->second==1){
			cout<<-1<<endl;
			return 0;
		}
		a[i]=mp.begin()->first;
		mp.begin()->second-=2;
		if(mp.begin()->second==0)mp.erase(mp.begin());
	}
	for(int i=1;i<=n;i++)
		cout<<a[i]<<" ";
	puts("");
	for(int i=1;i<=n;i++)
		cout<<a[i]<<" ";
	return 0;
}

---

C 小红关鸡

思路：

如果把鸡窝的位置放在数轴上，那么我们其实就是要找一段长为 $k$ 的区间，使得这个区间包含的鸡窝（也就是数轴上的点）的个数最多。

这有点像滑动窗口。假设有个长为 $k$ 的窗口，从最左边的鸡窝开始向右滑动，右端点每次移动到下一个鸡窝，然后把左边超出范围的鸡窝删掉，考虑用双端队列维护这个过程，每滑动一次就记录一下当前窗口中有多少鸡窝，取最大的即可。

code：

#include 
#include 
#include 
#include 
using namespace std;
const int maxn=1e5+5;

int n,k;
int a[maxn];
deque<int> q;

int main(){
	cin>>n>>k;
	for(int i=1;i<=n;i++)
		cin>>a[i];
	sort(a+1,a+n+1);
	int ans=0;
	for(int i=1;i<=n;i++){
		q.push_back(a[i]);
		while(a[i]-q.front()>k)q.pop_front();
		ans=max(ans,(int)q.size());
	}
	cout<<1.*ans/n;
	return 0;
}

---

D 小红的排列构造

思路：

题意说白了就是修改数组中的某些数，让 $1\sim n$ 出现一次且仅一次。

贪心地来想，如果排列中的某个数在给出的数组中有的话，我们就可以保留其中一个。而多余的和超出范围（$>n$）的数我们就需要把它修改成其他数。

所以做法就比较明确了，统计一下不符合条件的下标，然后再给它们分配排列中没有用到的数字。

code：

#include 
#include 
#include 
#include 
using namespace std;

int n;
vector<int> a;

int main(){
	cin>>n;
	set<int> S;
	int cnt=0;
	for(int i=1,t;i<=n;i++){
		cin>>t;
		if(!S.count(t) && t<=n)S.insert(t);
		else {
			cnt++;
			a.push_back(i);
		}
	}
	cout<<cnt<<endl;
	int i=1;
	for(auto x:a){
		while(S.count(i))i++;
		cout<<x<<' '<<i<<endl;
		i++;
	}
	return 0;
}

---

E 小红的无向图构造

思路：

比较麻烦的一道构造。

先不考虑凑出 $m$ 条边，单纯想怎么凑出满足 $a$ 数组。考虑一棵树，深度其实就是它到根节点的距离，深度为 $h$ 的点一定连着至少一个深度为 $h-1$ 的点，并且它一定不能去连其他深度的点，否则它本身或者连接的另一个点的深度就会发生变化。

也就是说，至少要有 $n-1$ 条边才能保证图联通。并且对一个距离 $1$ 号节点距离 $a_i$ 的点，至少要有一个距离为 $a_i-1$ 的点给它连着。也就是不能断层。

另外因为不允许重边和自环，因此 $m$ 太大的时候也是无解的。怎么找到这个最大值以及怎么构造呢？考虑深度为 $h$ 的点一定只能连着深度为 $h-1$ 或 $h$ 的点，因此深度为 $h$ 的点最多可以连出 $siz{e}_{h-1}\ast siz{e}_h$ 和 $C_{siz{e}_h}^2=\frac{siz{e}_h\ast (siz{e}_h-1)}{2}$ 条边，我们算出这个最大的可以连边的数量，然后和 $m$ 比较一下就知道有没有解了。

那么怎么连边呢。首先我们需要保证联通，所以需要先把最低限度的边连好。我们用个vector把每个深度的点存一下，然后深度为 $h$ 的所有点先跟 深度为 $h-1$ 的某个点连好边。然后再去连没有必要的边，并记录一下连了多少个，够了后面就不用再连没必要的边了。

code：

#include 
#include 
#include 
using namespace std;
typedef long long ll;
const int maxn=1e5+5;

int n,m,d[maxn];
vector<int> a[maxn];

int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>d[i];
		a[d[i]].push_back(i);
	}
	if(m<n-1){
		cout<<-1;
		return 0;
	}
	ll maxx=0,cnt=1;
	for(int i=1;a[i].size()!=0;i++){
		cnt+=a[i].size();
		maxx+=1ll*a[i-1].size()*a[i].size();
		maxx+=1ll*a[i].size()*(a[i].size()-1)/2;
	}
	if(maxx<m || cnt!=n){//m超出最大的边数 或 出现断层
		cout<<-1;
		return 0;
	}
	
	m-=n-1;
	vector<pair<int,int> > e;
	for(int i=1;a[i].size()!=0;i++){
		for(auto x:a[i])//必要的边
			e.push_back(make_pair(a[i-1][0],x));
		for(int j=1;j<a[i-1].size() && m;j++){//非必要的边 h-1 -> h
			for(auto x:a[i]){
				e.push_back(make_pair(a[i-1][j],x));
				m--;
				if(!m)break;
			}
		}
		for(int j=0;j<a[i].size() && m;j++)
			for(int k=j+1;k<a[i].size() && m;k++){//非必要的边 h -> h
				e.push_back(make_pair(a[i][j],a[i][k]));
				m--;
				if(!m)break;
			}
	}
	for(auto x:e)
		cout<<x.first<<" "<<x.second<<endl;
	return 0;
}

---

F，G 小红的子序列权值和

思路：

对一种选取方案，发现其实 $1$ 对乘积的结果是没有影响的，所以先不看 $1$，只看 $2$ 和 $3$。假如 $n$ 个数里一共有 $a$ 个 $2$ 和 $b$ 个 $3$。某种选取方案有 $x$ 个 $2$ 和 $y$ 个 $3$，那么总的因子个数就是 $(x+1)\ast (y+1)$（乘积结果为 $2^x\ast 3^y$，对一个因子，从 $x$ 个 $2$ 里可以选 $0\sim x$ 个 $2$，从 $y$ 个 $3$ 里可以选 $0\sim y$ 个 $3$，总的方案数就是 $(x+1)\ast (y+1)$。这个结论可以推广，对 $n=p_1^{c_1}\ast p_2^{c_2}\ast \cdots \ast p_m^{c_m}$ 的因子个数就是 ${\prod }_{i=1}^m(c_i+1)$）。而选到这个方案总的次数就是从 $a$ 个 $2$ 里选 $x$ 个 $2$，以及从 $b$ 个 $3$ 里选 $y$ 个 $3$，也就是选取 $x$ 个 $2$ 和 $y$ 个 $3$ 的方案的总贡献是 $C_a^x\ast C_b^y\ast (x+1)\ast (y+1)$。

最后对每个选取方案，我们可以往里面添加 $n-a-b$ 个 $1$ 中的任意个，也就是最后结果乘以 $2^{n-a-b}$，最后再减掉一个 什么都不选 的方案就行了。答案为：$$2^{n-a-b}\ast \sum _{x=0}^a\sum _{y=0}^b{C}_a^x\ast C_b^y\ast (x+1)\ast (y+1)-1$$$O(n)$ 预处理一下阶乘和阶乘的逆元，就可以 $O(n^2)$ 进行累加，可以过 F 题。

其实你会发现 $C_a^x$ 和 $(x+1)$ 这个部分和 $y$ 没有一点关系，所以可以提出来，同理 $C_b^y$ 和 $(y+1)$ 这个部分和 $x$ 没有一点关系，所以可以提出来。于是就得到了：$$2^{n-a-b}\ast \sum _{x=0}^a{C}_a^x\ast (x+1)\ast \sum _{y=0}^b{C}_b^y\ast (y+1)-1$$两个部分分开计算，时间复杂度 $O(n)$，可以通过 G 题。

code：

#include 
#include 
using namespace std;
typedef long long ll;
const int maxn=1e5+5;
const ll mod=1e9+7;

ll n,a,b;
ll fac[maxn],ifac[maxn];

ll qpow(ll a,ll b){
	b%=mod-1;
	ll base=a%mod,ans=1;
	while(b){
		if(b&1){
			ans*=base;
			ans%=mod;
		}
		base*=base;
		base%=mod;
		b>>=1;
	}
	return ans;
}
ll inv(ll x){return qpow(x,mod-2);}
ll C(int a,int b){//C_a^b 
	return fac[a]*ifac[b]%mod*ifac[a-b]%mod;
}

int main(){
	cin>>n;
	fac[0]=ifac[0]=1;
	for(int i=1;i<=n;i++)fac[i]=fac[i-1]*i%mod;
	ifac[n]=inv(fac[n]);
	for(int i=n;i>=1;i--)ifac[i-1]=ifac[i]*i%mod;
	
	a=b=0;
	for(int i=1,t;i<=n;i++){
		cin>>t;
		if(t==2)a++;
		else if(t==3)b++;
	}
	
	ll t1=0,t2=0;
	for(int y=0;y<=b;y++){
		t1=(t1+C(b,y)*(y+1))%mod;
	}
	for(int x=0;x<=a;x++){
		t2=(t2+C(a,x)*(x+1))%mod;
	}
	ll ans=t1*t2%mod;
	cout<<(qpow(2,n-a-b)*ans%mod-1+mod)%mod;
	return 0;
}