20211111 NOIP模拟赛

前言

好累呀！累死了！好不容易改完三道题！蒟蒻咆哮！！
日常挂分.jpg（数组开大爆了）
垫底次数+=1；

正题

T1：（简 单 图 论）
得分：$\color{red}{10}$

刚了一个小时放弃，然后乱写一个搜索。

正解：

将边按照d值的大小排序，从小到大依次枚举解锁当前边的时间情况。
使用三个矩阵：

$a[i][j]表示i与j之间有无一条路径$
$b[i][j]表示当前能否从i点走到j点$
$f[i][j]表示当前从i到j的路径长度$

其中a,b可以用bitset代替。f每一次用Floyd更新。

当枚举到一条边时，距离解锁该边还要走$\Delta d$步，我们就考虑在这几步中，他可以到达那些节点。以此更新b。

每走一步，a就要乘上自己一次，更新路径数量，再把a的幂与b相乘，这样更新b矩阵，注意这里a不会变，我们只使用它的值来乘方，乘方后的矩阵就是所有的走$\Delta d$的情况。

然后使用Floyd更新新加入的边对于路径长度的影响。

最后记录当前的$d$，再更新a。

点击查看代码

#include<bits/stdc++.h>
using namespace std;
const int inf=0x3f3f3f3f;
int n,m;
struct node{
	int u,v,d;
	bool operator < (const node &b){
		return d<b.d;
	}
}p[160];
const int N=160;
bitset<N> a[N],b[N];
int f[N][N];
void Mul(bitset<N> *a,bitset<N> *b){
	bitset<N> ret[N];
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if(a[i][j]){
				ret[i]|=b[j];
			}
		}
	}
	for(int i=1;i<=n;i++){
		a[i]=ret[i];
	}
	return ;
}

void Pow(bitset<N> *a,int b){
	bitset<N> ret[N];
	for(int i=1;i<=n;i++){
		ret[i][i]=1;
	}
	while(b!=0){
		if(b&1){
			Mul(ret,a);
		}
		Mul(a,a);
		b>>=1;
	}
	for(int i=1;i<=n;i++){
		a[i]=ret[i];
	}
	return ;
}
int main(){
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		cin>>p[i].u>>p[i].v>>p[i].d;
	}	
	sort(p+1,p+m+1);
	memset(f,inf,sizeof f);
	for(int i=1;i<=n;i++){//路径长度
		f[i][i]=0;
	}
	int cnt=0;
	int ans=inf;
	for(int i=1;i<=n;i++){
		b[i][i]=1;//自己可以到达自己
	}
	for(int i=1;i<=m;i++){
		int x=p[i].u,y=p[i].v,d=p[i].d;
		int delta=d-cnt;//$\Delta d$
		bitset<N> tmp[N];
		for(int i=1;i<=n;i++){
			tmp[i]=a[i];
		}
		Pow(tmp,delta);//快速幂
		Mul(b,tmp);
		for(int j=1;j<=n;j++){
			for(int k=1;k<=n;k++){
				f[j][k]=min(f[j][k],f[j][x]+1+f[y][k]);//更新路径长度
			}
		}
		for(int j=1;j<n;j++){
			if(b[1][j]){
				ans=min(ans,d+f[j][n]);//更新答案
			}
		}
		a[x][y]=1;//更新a
		cnt=d;
	}
	cout<<ans<<endl;
	return 0;
}

T2:
注意空间，注意空间，注意空间！！！

一道我最爱的构造题，可惜挂成0分了！

思路：
先不管其他限制，把矩阵按照顺序排列好。

这时，如果是奇数就不管。

如果是偶数，每一行的数值是$\frac{n+1}{2}$，每一列的数值是$\frac{n^2-n+2}{2}$

不管$n$是奇数还是偶数，每一列的数值是不变的整数，而每一行的数值在$n$为偶数时不成立。
因为我们要把每一行的数值改为整数，所以每一行的总和要加或减$\frac{n}{2}$的值。

可以把奇数行的最后一个与偶数行的$n/2$个交换，这样两行的数值都变为了整数。
当$n\% 4=0$时，这两列交换了偶数次，两列的数值为整数，但当$n\% 4=2$时，两行交换了奇数次，不满足要求。

为了让这两列满足要求，我们在最后两行交换时，交换$a[n-1][n-1],a[n][n/2-1]$这样矛盾就转移到了第$n-1$列和第$n/2-1$列上，为了消除，交换这两列其他某一行的两个元素即可，这样两列同时加上，减去n,数值还是整数。

点击查看代码

#include<bits/stdc++.h>
#define re register
//Orz huaruoji Orz llmmkk Orz _Iva Orz pigonered 
using namespace std;
int sit[5][5]={{0,0,0,0,0},{0,1,2,3,6},{0,4,5,7,8},{0,10,9,11,14},{0,13,12,15,16}};
int a[2001][2001];
int n;
int main(){
//	freopen("s.in","r",stdin);
//	freopen("s.out","w",stdout);
	scanf("%d",&n);
	if(n==2||n==0){
		cout<<-1<<endl;
		return 0;
	}else if(n%2==1){
		for(re int i=1;i<=n;i++){
			for(re int j=1;j<=n;j++){
				cout<<(i-1)*n+j<<' ';
			}
			cout<<"\n";
		}
		return 0;
	}else if(n%4==0){
		for(re int i=1;i<=4;i++){
			for(re int j=1;j<=4;j++){
				a[i][j]=sit[(i-1)%4+1][(j-1)%4+1];
			}
		}
		for(re int i=1;i<=4;i++){
			for(re int j=5;j<=n;j++){
				a[i][j]=a[i][j-4]+16;
			}
		}
		for(int i=5;i<=n;i++){
			for(int j=1;j<=n;j++){
				a[i][j]=a[i-4][j]+16*(n/4);
			}
		}
		for(re int i=1;i<=n;i++){
			for(re int j=1;j<=n;j++){
				cout<<a[i][j]<<' ';
			}
			cout<<"\n";
		}
		//cout<<check()<<endl;
	}else if(n%2==0){//正解
		int cnt =1;
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				a[i][j]=cnt++;
			}
		}
		for(int i=1;i<=n-3;i+=2){
			swap(a[i][n],a[i+1][n/2]);
		}
		swap(a[n-1][n-1],a[n][n/2-1]);
		swap(a[1][n-1],a[1][n/2-1]);
			for(re int i=1;i<=n;i++){
			for(re int j=1;j<=n;j++){
				cout<<a[i][j]<<' ';
			}
			cout<<"\n";
		}
		//cout<<check()<<endl;
	}
	
	return 0;
}

T3：

暴力可以有50分，可惜没时间了。

问题等价于从一个矩阵的$(x,y)$向上和右上走，每走一步会有$a_y$的贡献，最小化贡献。
tj原文：

发现一个神奇的性质，就是最优策略一定是从$(x,y)$走到某一列然后一直走到底因为如果
走到那一列更优那么一定会以最快的速度走到那一列，不可能出现转两次弯的情况，只能转一次弯。

证明：
如果转两次弯:

证明完成！
思路：

对于每一个询问$x,y$，考虑在y前面的x个数中选出x个数的最小和，因为每个数是又$[i-1,j-1] and [i,j-1]$更新而来的，要想最优就选一列走到底。

我们考虑最优的情况，第一个数选i个，后面的x-i个数就每个选1个，这样是最优的情况。

暴力是枚举每一列，然后算ans。有50分。

正解是使用线段树维护单调栈，找到单调递增的一个序列，在枚举序列上的每个点。

代码：

点击查看代码

#include<bits/stdc++.h>
#define int long long
#define in read()
using namespace std;
inline int read(){
	static char ch;
	int res=0,sign=1;
	while((ch=getchar())<'0'||ch>'9'){
		if(ch=='-'){
			sign=-1;
		}
	}
	res=ch-'0';
	while((ch=getchar())>='0'&&ch<='9'){
		res=res*10+ch-'0';
	}
	return res*sign;
}
const int N=1e6+100;
int n,Q;
int a[N],len,q[N],sum[N],lst[N];
int bin(int k){
	int l=1,r=len,mid;
	while(l<r){
		mid=l+r>>1;
		if(q[mid]<k){
			l=mid+1;
		}else{
			r=mid;
		}
	}
	return l;
}
int maxx[N*4];
void update(int k,int l,int r,int x,int v){
	if(l==r){
		maxx[k]=max(v,maxx[k]);
		return ;
	}
	int mid=l+r>>1;
	if(x<=mid){
		update(k<<1,l,mid,x,v);
	}else{
		update(k<<1|1,mid+1,r,x,v);
	}
	maxx[k]=max(maxx[k<<1],maxx[k<<1|1]);
}
int query(int k,int l,int r,int x,int y){
	if(l>=x&&r<=y){
		return maxx[k];
	}
	int res=0;
	int mid=l+r>>1;
	if(x<=mid){
		res=max(res,query(k<<1,l,mid,x,y));
	}
	if(mid<y){
		res=max(res,query(k<<1|1,mid+1,r,x,y));
	}
	return res;
}
signed main(){
//	freopen("y2.in","r",stdin);
//	freopen("y.out","w",stdout);
	n=in,Q=in;
	for(int i=1;i<=n;i++){
		a[i]=in,q[i]=a[i];
		sum[i]=sum[i-1]+a[i];
	}
	sort(q+1,q+n+1);
	len=unique(q+1,q+n+1)-(q+1);
	for(int i=1;i<=n;i++){
		int qr=bin(a[i])-1;
		if(qr){
			lst[i]=query(1,1,n,1,qr);//单调栈的前一项
		}else{
			lst[i]=0;
		}
		update(1,1,n,qr+1,i);
	}
	while(Q--){
		int x=in,y=in;
		int ans=1e18;
		for(int i=y;i>0&&i>y-x;i=lst[i]){
			ans=min(ans,sum[y]-sum[i]+(x-y+i)*a[i]);//贡献
		}
		cout<<ans<<endl;
	}
	
	return 0;
}

T4 咕咕