CSP提高组模拟1

我的微軟輸入法莫名其妙變成繁體了，你們有什麽頭緒嗎

狀態	題目
20 Time Exceeded	A 最短路
25 Time Exceeded	B 方格取数
0 Time Exceeded	C 数组
70 Time Exceeded	D 树

A.最短路

我赛时想了想，会不会 DIJ 不是很对，因为这个题在打的时候觉得，在跑最短路的时候沿途加上点权有点草率了，但是后面没写完，所以也没回来想

有点像

我四十分的物理卷子

（内心）：你做的这个对吗

我：管它呢，先画个圈，一会回来想，要不写不完了

（内心）：你本来也写不完，要不再看看这题

（在想起一些不好的回忆（因为太磨叽挂了五十分）之后，还是毅然地跳了）

（过了一会）

（内心）：跳了这么多，你这不也没写完

我：我草我前面还有题没想

所以这个题还是用 Floyed，为啥要点权从小到大排序，其实这么一听觉得真是太对了，但是我懒得想了，所以还是三遍 Floyed 来得实在（只需要保证完全更新就行了）

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int inf=0x3f3f3f3f3f3f3f3f;
int mp[301][301];
int dis[301][301];
int w[301];
int n,m,q;
void floyd(){
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                int p=mp[i][k]+mp[k][j]+max(dis[i][k],dis[k][j]);
                if((p<mp[i][j]+dis[i][j])&&mp[i][k]<inf&&mp[k][j]<inf){
                    mp[i][j]=mp[i][k]+mp[k][j];
                    dis[i][j]=max(dis[i][k],dis[k][j]);
                }
            }
        }
    }
}
signed main(){
	freopen("path.in","r",stdin);
	freopen("path.out","w",stdout);
    cin>>n>>m>>q;
    for(int i=1;i<=n;i++){
        cin>>w[i];
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            if(i==j) mp[i][j]=0;
            else mp[i][j]=inf;
        }
    }
    for(int i=1;i<=m;i++){
        int x,y,z;
        cin>>x>>y>>z;
        if(mp[x][y]>z){
            mp[x][y]=z;
            mp[y][x]=z;
            dis[x][y]=max(w[x],w[y]);
            dis[y][x]=max(w[x],w[y]);
        }
    }
    floyd();floyd();floyd();
    for(int i=1;i<=q;i++){
        int x,y;
        cin>>x>>y;
        int res=mp[x][y]+dis[x][y];
        cout<<(res>=0x3f3f3f3f3f3f3f3f?-1:res)<<endl;
    }
}

B. 方格取数

这个题的 \(n^4\) 挺好想的，我因为没什么头绪打的也是 \(n^4\) 暴力，没想到还能拿点分

如果有一个点大于等于 \(k\) 且小于等于 \(2k\) ，那么我们直接输出这个点即可

如果有一个点大于 \(2k\) ，那么我们一定不可以选这个点，和包括它的矩形

那么现在这个矩阵上只剩下不能选的点和权值小于 \(k\) 的点了，否则跑不到这里就输出答案了.

因此我们现在在这个简化的矩阵上考虑答案

我们可以考虑先找出一个最大的矩阵，即使它的权值大于 \(2k\)，在我们一点点减少的过程中，因为所有节点都小于 \(k\)，一定会在 \([k,2k]\) 内出现一次，因此直接大力删就行了. 删下来以后（其实就是切开了）要判一下哪边比较大（或者直接合法了，那更好）

洛谷上过了，咱们题库上 \(n\) 和 \(k\) 居然是反的，答案坐标也是反的 ，题库上莫名其妙 T 了， \(40\) 分，懒得改了，这并不是 AC 代码

#include<bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
#define N 2001
int k,n;
long long a[N][N];
long long sum[N][N];
int up[N][N],leftt[N],rightt[N];
long long ask(int lx,int ly,int ux,int uy){
	return sum[ux][uy]-sum[lx-1][uy]-sum[ux][ly-1]+sum[lx-1][ly-1];
}
long long sumx;
int mat_sx,mat_sy,mat_ex,mat_ey;
void cutline(int x,int l,int r){
	sumx=ask(x,l,x,r);
	for(int i=r;i>=l;--i){
		sumx-=a[x][i];
		if(sumx>=k and sumx<=(k<<1)){
			printf("%d %d %d %d",x,l,x,i-1);
			exit(0);
		}
	}
}
void update(int lx,int ly,int ux,int uy){
	long long t=ask(lx,ly,ux,uy);
	if(t>=k and t<=(k<<1)){
		printf("%d %d %d %d",lx,ly,ux,uy);
		exit(0);
	}
	if(t>sumx){
		sumx=t;
		mat_sx=lx,mat_sy=ly,mat_ex=ux,mat_ey=uy;
	}
}
stack<int>st;
signed main(){
	freopen("matrix.in","r",stdin);
	freopen("matrix.out","w",stdout);
	cin>>n>>k;
	for(int i=1;i<=n;++i){
		for(int j=1;j<=n;++j){
			cin>>a[i][j];
			sum[i][j]=sum[i][j-1]+a[i][j];
			if(a[i][j]>=k and a[i][j]<=(k<<1)){
				printf("%d %d %d %d",i,j,i,j);
				return 0;
			}
		}
		for(int j=1;j<=n;++j){
			sum[i][j]+=sum[i-1][j];
		}
	}
	for(int i=1;i<=n;++i){
		for(int j=1;j<=n;++j){
			if(a[i][j]<k){
				up[i][j]=up[i-1][j]+1;
			}
		}
		while(!st.empty()) st.pop();
		st.push(0);
		up[i][0]=-1;
		for(int j=1;j<=n;++j){
			while(!st.empty() and up[i][st.top()]>=up[i][j]) st.pop();
			leftt[j]=st.top()+1;
			st.push(j);
		}
		while(!st.empty()) st.pop();
		st.push(n+1);
		up[i][n+1]=-1;
		for(int j=n;j>=1;--j){
			while(!st.empty() and up[i][st.top()]>=up[i][j]) st.pop();
			rightt[j]=st.top()-1;
			st.push(j);
			if(up[i][j]) update(i-up[i][j]+1,leftt[j],i,rightt[j]);
		}
	}
	if(sumx<k){
		printf("-1\n");
		return 0;
	}
	for(int i=mat_ex;i>=mat_sx;--i){
		long long t=ask(i,mat_sy,i,mat_ey);
		if(t>=k and t<=(k<<1)){
			printf("%d %d %d %d",i,mat_sy,i,mat_ey);
			return 0;
		}
		else if(t>(k<<1)){
			cutline(i,mat_sy,mat_ey);
		}
		else{
			sumx-=t;
			if(sumx>=k and sumx<=(k<<1)){
				printf("%d %d %d %d",mat_sx,mat_sy,i-1,mat_ey);
				return 0;
			}
		}
	}
}

C.数组

没想到搞了半天，线段树写对了，状压写对了，\(tag\) 写对了（其实是没写对，但是差不多对了），但是求 \(\phi\) 的时候寄了

这个题就是显然了，欧拉函数只要会求的就明白，直接根据积性函数（而且质因数也是差不多那种性质，所以极其好维护，取个或就行了）维护一下区间欧拉函数，扔到线段树里，拿出来的时候做个乘法就行了.

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int p=1000000007;
int power(int x,int t,int mod){
	int ans=1,base=x;
	while(t){
		if(t&1){
			ans=(ans*base)%mod;
		}
		base=base*base%mod;
		t>>=1;
	}
	return ans;
}
struct tree{
	int val;
	int p;
	int lazy,lazyP;
	tree(){
		val=1;
		lazy=1;
		p=0;
		lazyP=0;
	}
} t[1600001];
int n,q;
int a[1600001];
int f[1001],inv[1001];
int prime[]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293};
void update(int x){
	t[x].val=t[x*2].val*t[x*2+1].val%p;
	t[x].p=t[x*2].p|t[x*2+1].p;
}
void pushdown(int x,int l,int m,int r){
    t[x*2].val=t[x*2].val*power(t[x].lazy,m-l+1,p)%p;
    t[x*2+1].val=t[x*2+1].val*power(t[x].lazy,r-m,p)%p;
    t[x*2].lazy=t[x*2].lazy*t[x].lazy%p;
    t[x*2+1].lazy=t[x*2+1].lazy*t[x].lazy%p;
    t[x*2].p|=t[x].lazyP;
    t[x*2+1].p|=t[x].lazyP;
    t[x*2].lazyP|=t[x].lazyP;
    t[x*2+1].lazyP|=t[x].lazyP;
	t[x].lazy=1;
	t[x].lazyP=0;
}
void build(int l,int r,int x){
	if(l==r){
		t[x].val=a[l];
		for(int i=0;i<62;++i){
			if(a[l]%prime[i]==0){
				t[x].p|=(1ll)<<i;
			}
		}
		return;
	}
	int m=(l+r)/2;
	build(l,m,x*2);
	build(m+1,r,x*2+1);
	update(x);
}
void update(int x,int l,int r,int delta,int prime,int cl,int cr){
	if(cl>r or cr<l) return;
	if(l<=cl and cr<=r){
		t[x].val=t[x].val*power(delta,cr-cl+1,p)%p;
		t[x].lazy=t[x].lazy*delta%p;
		t[x].p|=prime;
		t[x].lazyP|=prime;
		return;
	}
	const int m=(cl+cr)/2;
	pushdown(x,cl,m,cr);
	update(x*2,l,r,delta,prime,cl,m);
	update(x*2+1,l,r,delta,prime,m+1,cr);
	update(x);
}
tree find(int x, int l, int r, int cl, int cr) {
	if(cl>r or cr<l) return tree();
	if(l<=cl and r>=cr) return t[x];
	int m=(cl+cr)/2;
	pushdown(x,cl,m,cr);
	tree n;
	tree ll=find(x*2,l,r,cl,m);
	tree rr=find(x*2+1,l,r,m+1,cr);
	n.val=ll.val*rr.val%p;
	n.p=ll.p|rr.p;
	return n;
}
signed main(){
	freopen("array.in","r",stdin);
	freopen("array.out","w",stdout);
	cin>>n>>q;
	for(int i=1;i<=n;++i){
		cin>>a[i];
	}
	build(1,n,1);
	inv[1]=1;
	for(int i=2;i<=300;++i){
		inv[i]=p-(p/i)*inv[p%i]%p;
	}
	for(int i=0;i<62;++i){
		f[i]=inv[prime[i]]*(prime[i]-1)%p;
	}
	for(int i=1;i<=q;i++){
		int opt,x,y;
		cin>>opt>>x>>y;
		if(opt==1){
			int k;
			cin>>k;
			int t=0;
			for(int i=0;i<62;++i){
				if(k%prime[i]==0){
					t|=(1ll)<<i;
				}
			}
			update(1,x,y,k,t,1,n);
		}
		else{
			tree ans=find(1,x,y,1,n);
			int phi=ans.val;
			for(int i=0;i<62;++i){
				if(ans.p>>i&1){
					phi=phi*f[i]%p;
				}
			}
			cout<<phi%p<<endl;
		}
	}
}

D.树

懒得喷，谁造了组链的数据，还给那么大分

随机数据的话，考虑到先求个 Lca，然后两个节点都往 Lca 跳，每次都跳步长，一直到跳不动了，我们可以发现此时无论两个点位于哪里，中间一定不会再有其他点了.

因此倍增优化下 Lca，正好也能用来二进制优化跳步长，就能拿到这道题的大部分分.

啥比链，不写，感谢 luobotianle 提供的只过了链的假代码，拼上就行了

UPD: 原來链的不用根号分治也能过，这数据也太水了

#include<bits/stdc++.h>
using namespace std;
int n,w[50001];
vector<int>e[50001];
int fa[17][50001],deep[50001];
int xx[50001],yy[50001];
void dfs(int now,int last,int nowdeep){
	fa[0][now]=last;
	deep[now]=nowdeep;
	for(int i:e[now]){
		if(i!=last) dfs(i,now,nowdeep+1);
	}
}
void prework(){
	for(int i=1;i<=16;++i){
		for(int j=1;j<=n;++j){
			fa[i][j]=fa[i-1][fa[i-1][j]];
		}
	}
}
int jumpto(int x,int step){
	int st=0;
	while(step){
		if(step&1){
			x=fa[st][x];
		}
		step>>=1;
		st++;
	}
	return x;
}
int lca(int x,int y){
	if(deep[x]<deep[y]) swap(x,y);
	for(int i=16;i>=0;--i){
//		cout<<"deep "<<deep[x]<<" "<<deep[y]<<" "<<(1<<i)<<endl;
		if(deep[x]-deep[y]>=(1<<i)){
//			cout<<"jump "<<i<<endl;
			x=fa[i][x];
		}
	}
	for(int i=16;i>=0;--i){
		if(fa[i][x]!=fa[i][y]){
			x=fa[i][x];
			y=fa[i][y];
		}
	}
//	cout<<deep[x]<<" = "<<deep[y]<<endl;
//	while(deep[x]!=deep[y]) x=fa[0][x];
//	int cnt=0;
//	while(x!=y){
//		cnt++;
//		x=fa[0][x],y=fa[0][y];
//	}
//	cout<<"jumpcnt "<<cnt<<endl;
//	return x;
	return x==y?x:fa[0][x];
}
int not_lca(int x,int y,int steplen){
	int ans=w[x]+w[y],root=lca(x,y);
//	cout<<"root "<<root<<endl;
//	cout<<"++ "<<x<<" "<<y<<endl;
	while(deep[x]-deep[root]>=steplen){
		x=jumpto(x,steplen);
		ans+=w[x];
//		cout<<"+ "<<x<<endl;
	}
	while(deep[y]-deep[root]>=steplen){
		y=jumpto(y,steplen);
//		if(y!=root){
			ans+=w[y];
//			cout<<"+ "<<y<<endl;
//		}
	}
	if(x==y) ans-=w[y];
	return ans;
}
namespace lian{
	const int N=5e4+5;
	int a[N],b[N],c[N],x,y;
	struct edge{
		int next,to;
	}e[N*2];
	int h[N],cnt;
	void add(int u,int v){
		e[++cnt]={h[u],v};
		h[u]=cnt;
	}
	int fa[N],top[N],son[N],dep[N],siz[N];
	void dfs1(int x,int f){
		fa[x]=f;
		dep[x]=dep[f]+1;
		siz[x]=1;
		int maxc=0;
		for(int i=h[x];i;i=e[i].next){
			int to=e[i].to;
			if(to==f)continue;
			dfs1(to,x);
			siz[x]+=siz[to];
			if(siz[to]>maxc){
				maxc=siz[to];
				son[x]=to;
			}
		}
	}
	void dfs2(int x,int topf){
		top[x]=topf;
		if(!son[x])return;
		dfs2(son[x],topf);
		for(int i=h[x];i;i=e[i].next){
			int to=e[i].to;
			if(to==fa[x]||to==son[x])continue;
			dfs2(to,to);
		}
	}
	int lca(int x,int y){
		while(top[x]!=top[y]){
	//		cout<<dep[top[x]]<<" "<<dep[top[y]]<<"\n";
			if(dep[top[x]]<dep[top[y]])swap(x,y);
			x=fa[top[x]];
		}
		return x;
	}
	void solve1(){
		dfs2(1,1);dfs2(1,1);
		for(int i=1;i<=n;i++)cin>>b[i];
		for(int i=2;i<=n;i++)cin>>c[i];
		for(int i=2;i<=n;i++){
			int st=b[i-1],ed=b[i];
			if(st>ed)swap(st,ed);
			int ans=0;
			for(int j=st;j<=ed;j+=c[i]){
				ans+=a[j];
			}
			cout<<ans<<"\n";
		}
	}
	int main(){
		for(int i=1;i<=n;++i){
			a[i]=w[i];
		}
		for(int i=1;i<n;i++){
			add(xx[i],yy[i]);
			add(yy[i],xx[i]);
		}
		solve1();
		return 0;
		dfs1(1,1);dfs2(1,1);
	//	for(int i=1;i<=n;i++){
	//		cout<<fa[i]<<" "<<dep[i]<<"\n";
	//	}
		for(int i=1;i<=n;i++)cin>>b[i];
		for(int i=2;i<=n;i++)cin>>c[i];
		for(int i=2;i<=n;i++){
			int st=b[i-1],ed=b[i];
			int t=c[i];
			int f=lca(st,ed);
			int ans=0;
			if(f==st||f==ed){
				if(dep[st]<dep[ed])swap(st,ed);
				ans=a[st];
				while(st!=ed){
					for(int j=1;j<=t;j++)st=fa[st];
					ans+=a[st];
				}
				cout<<ans<<"\n";
			}
			else{
				ans=a[st]+a[ed];
				while(dep[st]-dep[f]>=t){
					for(int j=1;j<=t;j++)st=fa[st];
					ans+=a[st];
				}
				while(dep[ed]-dep[f]>=t){
					for(int j=1;j<=t;j++)ed=fa[ed];
					ans+=a[ed];
				}
				if(st==f&&ed==f)ans-=a[f];
				cout<<ans<<"\n";
			}
		}
		return 0;
	}
}
int b[50001],c[50001];
int main(){
	freopen("tree.in","r",stdin);
	freopen("tree.out","w",stdout);
	cin>>n;
	for(int i=1;i<=n;++i){
		cin>>w[i];
	}
	bool islian=true;
	for(int i=1;i<=n-1;++i){
		cin>>xx[i]>>yy[i];
		if(abs(xx[i]-yy[i])!=1) islian=false;
		e[xx[i]].push_back(yy[i]);
		e[yy[i]].push_back(xx[i]);
	}
	if(islian){
		lian::main();
	}
	else{
		dfs(1,0,1);
		prework();
		for(int i=1;i<=n;++i){
			cin>>b[i];
		}
		for(int i=1;i<=n-1;++i){
			cin>>c[i];
		}
		for(int i=1;i<=n-1;++i){
			cout<<not_lca(b[i],b[i+1],c[i])<<endl;
		}
	}
}