noip模拟30

\(\color{white}{\mathbb{缀以无尽之群星点点，饰以常青之巨木郁郁，可细斟木纹叶脉，独无可极苍穹之览，名之以：密林}}\)

---

看完题后感觉整套题都没什么思路，而且基本上整场考试确实是这样

倒序开题，发现 \(t3\) 的做法没有优化空间了，\(t2\) 发现了一些规律，但是卡在求拓扑序上，最后乱搞 \(t1\)，本来复杂度及其不正确，但是测的在随机数据下还是很可观的

事实上最后分数比预期高多了

---

A. 毛一琛

考完 cyh 说才发现是曾经随机跳题跳到的USACO的题，但不幸的是当时直接跳了……

如果直接枚举的话有三种状态：分到第一组，分到第二组，不要，这样是 \(3^n\)

对于这种范围刚刚超的，而且还是枚举集合的题，常常可以使用折半搜索

对于前半段共 \(\frac{n}{2}\) 个元素暴搜一下，消耗 \(3^{\frac{n}{2}}\)，并且把每种状态记录在其和的 \(vector\) 里面

右边再重复上述操作，设求出的和为 \(sum\)，那么在左边寻找 \(-sum\) 的集合，并且更新和起来的答案即可

代码实现

#include<bits/stdc++.h>
using namespace std;
const int maxn=55,maxm=1e6+1e5+5;
int n,a[maxn],half,tot,ans;
bool vis[maxm];
map<int,int>mp;
vector<pair<int,int> >num[maxm];
void dfs1(int pos,int sum,int S1,int S2){
	if(pos==half+1){
		if(mp.find(sum)==mp.end())mp[sum]=++tot;
		num[mp[sum]].push_back(make_pair(S1,S2));
		return ;
	}
	dfs1(pos+1,sum,S1<<1,S2<<1);
	dfs1(pos+1,sum+a[pos],S1<<1|1,S2<<1);
	dfs1(pos+1,sum-a[pos],S1<<1,S2<<1|1);
	return ;
}
void dfs2(int pos,int sum,int S1,int S2){
	if(pos==n+1){
		if(mp.find(-sum)==mp.end())return ;
		int id=mp[-sum];
		for(int i=0;i<num[id].size();i++){
//			cout<<"hhh";
			vis[S1|S2|((num[id][i].first|num[id][i].second)<<(n-half))]=true;
		}
		return ;
	}
	dfs2(pos+1,sum,S1<<1,S2<<1);
	dfs2(pos+1,sum+a[pos],S1<<1|1,S2<<1);
	dfs2(pos+1,sum-a[pos],S1<<1,S2<<1|1);
	return ;
}
int main(){
	cin>>n;
	half=n/2;
//	if(n>=10)half+=3;
	for(int i=1;i<=n;i++)cin>>a[i];
	dfs1(1,0,0,0);
	dfs2(half+1,0,0,0);
	for(int i=1;i<=(1<<n)-1;i++)if(vis[i])ans++;
	cout<<ans;
	return 0;
}

---

B. 毛二琛

考场上想到可以根据先后顺序建边，相当于求有向图的拓扑序个数

然后想到以前有到叫 \(SAO\) 的题，然而当时咕咕咕了……

正解是用 \(dp\) 来做

设 \(f[i][j]\) 表示第 \(i\) 个数在前 \(i\) 个数形成的图中拓扑序为 \(j\) 的方案数

考虑从 \(f[i-1][k]\) 转移

如果 \(i-1\) 向 \(i\) 连边，相当于如果 \(i\) 的拓扑序为 \(j\)，那么 \(k\) 的范围为 \([1,j-1]\)

如果 \(i\) 向 \(i-1\) 连边，\(k\) 的范围为 \([j,i]\) (可以取到 \(j\) 是因为加入 \(i\) 这个数相当于把值域往后平移一位，那么原来的 \(j\) 现在相当于 \(j+1\)，是满足条件的)

然后发现 \(k\) 的值域是连续的，可以前缀和优化一下

代码实现

#include<bits/stdc++.h>
using namespace std;
int read(){
	int x=0,f=1;
	char ch=getchar();
	while(!isdigit(ch)){
		if(ch=='-')f=-1;
		ch=getchar();
	}
	while(isdigit(ch)){
		x=x*10+ch-48;
		ch=getchar();
	}
	return x*f;
}
const int maxn=5005;
const int mod=1e9+7;
int n,a[maxn],f[2][maxn],g[2][maxn],ans;
bool le[maxn];//rk[i]<rk[i+1]
int main(){
	n=read();
	for(int i=0;i<n;i++)a[i]=read();
	for(int i=0;i<n;i++){
		if(a[i]<i){//往左走
			for(int j=a[i];j<=i-2;j++)le[j]=true;
		}
		else{
			if(i>0)le[i-1]=true;
			le[a[i]-1]=true;
		}
	}
	f[0][1]=g[0][1]=1;
	for(int i=1;i<=n-2;i++){
		for(int j=1;j<=i+1;j++){
			if(le[i-1])f[i&1][j]=(g[(i-1)&1][i]-g[(i-1)&1][j-1]+mod)%mod;
			else f[i&1][j]=g[(i-1)&1][j-1];
		}
		for(int j=1;j<=i+1;j++){
			g[i&1][j]=(g[i&1][j-1]+f[i&1][j])%mod;
		}
	}
	for(int i=1;i<=n;i++)ans=(ans+f[(n-2)&1][i])%mod;
	cout<<ans;
	return 0;
}

---

B. 毛三琛

玄学题

首先应该乖乖地按照题目上说的确定 \(x\)（考场上因为加了个小优化所以不得不先二分再定 \(x\))

当 \(x\) 随机打乱后，最优解的更新序列长度期望是 \(logP\) 的

那么只需要每次开始二分前，\(O(n)\) 判断一下当前 \(x\) 是否比当前答案优即可

代码实现

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+5;
int n,p,k,a[maxn],ans,b[maxn],x;
int read(){
	int x=0,f=1;
	char ch=getchar();
	while(!isdigit(ch)){
		if(ch=='-')f=-1;
		ch=getchar();
	}
	while(isdigit(ch)){
		x=x*10+ch-48;
		ch=getchar();
	}
	return x*f;
}
bool check(int limit,int x){
	int cnt=1,sum=0;
	for(int i=1;i<=n;i++){
		int val=(a[i]+x)%p;
		if(val>limit) return false;
		if(sum+val<=limit)sum+=val;
		else sum=val,cnt++;
		if(cnt>k)break;
	}
	if(cnt<=k)return true;
	return false;
}
int main(){
	srand(time(0));
	n=read();
	p=read();
	k=read();
	for(int i=1;i<=n;i++)a[i]=read(),ans+=a[i];
	for(int i=0;i<p;i++)b[i]=i;
	random_shuffle(b,b+p);
	for(int i=0;i<p;i++){
		x=b[i];
		if(check(ans,x)){
			int l=0,r=ans+1;
			while(l<r){
				int mid=l+r>>1;
				if(check(mid,x))r=mid;
				else l=mid+1;
			}
			ans=l;
		}
	}
	cout<<ans;
	return 0;
}

\(\color{white}{\mathbb{溯洄从之，道阻且长}}\)