noip 2018 模拟赛1

最新推荐文章于 2023-08-20 00:12:39 发布
最新推荐文章于 2023-08-20 00:12:39 发布
阅读量283 收藏
点赞数
分类专栏： 离线赛-总结 文章标签： dp 虚树 贪心
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Caristra/article/details/83151717
版权

T 1 T_1 T1​——matrix(3118)

Description:

在一个 n ∗ m n*m n∗m的只包含0,1的矩形中，求有多少个特殊的子矩形，特殊的字矩形满足
它的四条边上都是1，内部的0,1个数差不超过1，大小至少为2*2。
n , m ≤ 300 n,m\le300 n,m≤300

Solution:

  • 对于找一个字矩形的问题，我们可以先尝试地枚举一条边，作为长，再枚举一下宽。这样就是 Θ ( n 2 m ) \Theta(n^2m) Θ(n2m)。
  • 那么剩下的判定一定是 Θ ( 1 ) \Theta(1) Θ(1)的，即用前缀和维护该边1的个数。
  • 但是关键的条件是内部的0,1个数差不超过1，其实也就是在枚举宽的同时，维护一个0,1个数差的前缀，接着记录每个的0,1个数差的出现次数。
  • 那么统计答案就可以由差为-1,0,1的状态转移即可。

Code:

#include<bits/stdc++.h>
using namespace std;
#define REP(i,f,t) for(int i=(f),i##_end_=(t);i<=i##_end_;++i)
#define ll long long

const int N=302,M=90000;

int n,m;
int A[N][N];
int col[N][N];
int cnt[M*2+5],mark[M*2+5];

int main(){
//	freopen("matrix.in","r",stdin);
//	freopen("matrix.out","w",stdout);
	scanf("%d%d",&n,&m);
	REP(i,1,n) REP(j,1,m) scanf("%d",&A[i][j]),col[i][j]=col[i-1][j]+A[i][j];
	
	int ans=0;
	REP(i,1,n) REP(j,i+1,n){
		int tot=0,sum=0,len=j-i+1;
		REP(k,1,m){
			int res=(len-2)-2*(col[j-1][k]-col[i][k]);
			if(len==col[j][k]-col[i-1][k]){
				ans+=cnt[sum+M]+cnt[sum+M-1]+cnt[sum+M+1];
                cnt[sum+M+res]++;
                mark[++tot]=sum+M+res;
			}
			if(!A[j][k] || !A[i][k]) {
				REP(l,1,tot)cnt[mark[l]]=0;
				tot=0;
			}
			sum+=res;
		}
		REP(l,1,tot) cnt[mark[l]]=0;
	} 
	printf("%d\n",ans);
	return 0;
}

T 2 T_2 T2​——build(2960)

Description:

一个有 n n n个格子的带子，每个格子可以涂成黑色或白色，而对于一条涂好的带子，对于每一个格子，它的花费为与之不同颜色的最近的距离和当前格子的颜色权值的乘积，即 c o s t i = d i s i ∗ v a l [ i ] [ c o l i ] , c o l i cost_i=dis_i*val[i][col_i],col_i costi​=disi​∗val[i][coli​],coli​为0或1，表示黑白。
求这带子的最小花费。
n ≤ 4000 , v a l [ i ] [ 0 / 1 ] ≤ 1 0 5 n\le4000,val[i][0/1]\le10^5 n≤4000,val[i][0/1]≤105

Solution:

  • 此题关键在于对于每个格子的与它不同颜色的格子的最近距离很难确定，或者说找到最优的。
  • 那么我们就定义一个准确的方向，使得一些格子的最近距离一定在它的左边或右边，即分治。
  • 我们可以划分两个区间 [ L , m i d ] , [ m i d + 1 , R ] [L,mid],[mid+1,R] [L,mid],[mid+1,R]，使区间 [ L , m i d ] [L,mid] [L,mid]的格子的最近距离都在它的右边，区间 [ m i d + 1 , R ] [mid+1,R] [mid+1,R]的格子的最近距离都在它的左边。
  • 同样是通过 d p dp dp来定义状态来找到最后的最优解。
  • 即 d p [ i ] [ 0 / 1 ] dp[i][0/1] dp[i][0/1]表示前 i i i个格子，到第 i i i个格子是，它的状态为黑色或白色的最优解。
  • 那么转移就是通过刚刚的分治思想，我们就需要预处理出对于每格子向左或向右走 k k k步的花费。

Code:

#include<bits/stdc++.h>
using namespace std;
#define REP(i,f,t) for(int i=(f),i##_end_=(t);i<=i##_end_;++i)
#define SREP(i,f,t) for(int i=(f),i##_end_=(t);i<i##_end_;++i)
#define DREP(i,f,t) for(int i=(f),i##_end_=(t);i>=i##_end_;--i)
#define ll long long
template<class T>inline bool chkmin(T &x,T y){return x>y?x=y,1:0;}

const int N=4010;

int n;
struct node{
	int a,b;
}A[N];

struct p20{
	void solve(){
		SREP(i,0,n) scanf("%d%d",&A[i].a,&A[i].b);
		ll ans=0x3f3f3f3f;
		int t[11];
		SREP(s,1,(1<<n)-1){
			memset(t,0,sizeof(t));
			SREP(i,0,n) if(s&(1<<i)) t[i]=1;
			ll res=0;
			
			SREP(i,0,n){
				if(t[i]){
					REP(k,1,n) {
						if(i-k>=0 && !t[i-k]) {res+=k*A[i].b;break;}
						if(i+k<n && !t[i+k]) {res+=k*A[i].b;break;}
					}
				}
				else {
					REP(k,1,n){
						if(i-k>=0 && t[i-k]) {res+=k*A[i].a;break;}
						if(i+k<n && t[i+k]) {res+=k*A[i].a;break;}	
					}
				}
			}
			chkmin(ans,res);
		}
		printf("%lld\n",ans);
	}
}p1;

struct p100{
	
	int A[2][N];
	ll L[2][N],R[2][N],sum[2][N];
	ll dp[2][N];
	
	void solve(){
		memset(dp,-1,sizeof(dp));
		REP(i,1,n) scanf("%d%d",&A[0][i],&A[1][i]);
		SREP(i,0,2){
			REP(j,1,n) sum[i][j]=sum[i][j-1]+A[i][j];
			REP(j,1,n) L[i][j]=L[i][j-1]+j*A[i][j];
			DREP(j,n,1) R[i][j]=R[i][j+1]+(n+1-j)*A[i][j];
		}
		dp[0][0]=dp[1][0]=0;
		REP(i,1,n) SREP(j,0,i) SREP(k,0,2){
			ll res=0;
			int l=j+1,r=i;
			int mid=(j+i+1)>>1;
			if(j+1==1 && i==n) res=1e17;
			else if(j+1==1) res=R[!k][l]-R[!k][r+1]-(sum[!k][r]-sum[!k][l-1])*(n-r);
			else if(r==n) res=L[!k][r]-L[!k][l-1]-(sum[!k][r]-sum[!k][l-1])*(l-1);
			else res=L[!k][mid]-L[!k][l-1]-(sum[!k][mid]-sum[!k][l-1])*(l-1)+R[!k][mid+1]-R[!k][r+1]-(sum[!k][r]-sum[!k][mid])*(n-r);
			if(~dp[k][i]) chkmin(dp[k][i],dp[!k][j]+res);
			else dp[k][i]=dp[!k][j]+res;
		}
		printf("%lld\n",min(dp[0][n],dp[1][n]));
	}
}p2;

int main(){
//	freopen("build.in","r",stdin);
//	freopen("build.out","w",stdout);
	scanf("%d",&n);
	
	if(n<=10) p1.solve();
	else p2.solve();
	
	return 0;
}

T 3 T_3 T3​——network(3111)

Description:

有一棵 n n n个节点的树，每个节点有一个 v a l i val_i vali​，求出所有 v a l val val互质的节点的距离和。
n , v a l i ≤ 1 0 5 n,val_i\le10^5 n,vali​≤105

Solution:

  • 一道非常传统的数据结构题，首先对于互质，无非是要通过容斥或莫比乌斯反演来统计答案，而关键就是怎样知道之间距离，发现复杂度是不够的。
  • 这里引入一个新知识——虚树。
  • 虚树的作用即保留原树上有用的节点，期望虚树的大小为 log ⁡ n \log n logn，这样就能达到一个 log ⁡ \log log，而接下来就是暴力莫比乌斯反演，而 1 0 5 10^5 105的质因数只有8个，因子只有128个，那么复杂度为 Θ ( n log ⁡ n ∗ 64 ) \Theta(n\log n*64) Θ(nlogn∗64)

Code:

#include<bits/stdc++.h>
using namespace std;
#define REP(i,f,t) for(int i=(f),i##_end_=(t);i<=i##_end_;++i)
#define SREP(i,f,t) for(int i=(f),i##_end_=(t);i<i##_end_;++i)
#define DREP(i,f,t) for(int i=(f),i##_end_=(t);i>=i##_end_;--i)
#define ll long long
template<class T>inline bool chkmin(T &x,T y){return x>y?x=y,1:0;}
template<class T>inline bool chkmax(T &x,T y){return x<y?x=y,1:0;}
template<class T>inline void Rd(T &x){
    x=0;char c;
    while((c=getchar())<48);
    do x=(x<<1)+(x<<3)+(c^48);
    while((c=getchar())>47);
}
 
const int N=1e5+2;
 
int n;
int val[N];
 
int head[N],qwq;
struct edge{
    int to,nxt;
}E[N<<1];
void addedge(int x,int y){E[qwq]=(edge){y,head[x]};head[x]=qwq++;}
 
int Mx;
 
int fa[N],dep[N],sz[N],son[N],top[N];

struct p30{
	
	int gcd(int a,int b){return !b?a:gcd(b,a%b);}
     
    void dfs1(int x,int f){
        fa[x]=f;
        dep[x]=dep[f]+1;
        sz[x]=1;
        for(int i=head[x];~i;i=E[i].nxt){
            int y=E[i].to;
            if(y==f)continue;
            dfs1(y,x);
            sz[x]+=sz[y];
            if(sz[son[x]]<sz[y])son[x]=y;
        }
    }
     
    void dfs2(int x,int tp){
        top[x]=tp;
        if(son[x]) dfs2(son[x],tp);
        for(int i=head[x];~i;i=E[i].nxt){
            int y=E[i].to;
            if(y==fa[x] || y==son[x]) continue;
            dfs2(y,y);
        }
    }
     
    int Lca(int x,int y){
        while(top[x]!=top[y]){
            if(dep[top[x]]<dep[top[y]])swap(x,y);
            x=fa[top[x]]; 
        }
        return dep[x]<dep[y]?x:y;
    }
 
    void solve(){
        dfs1(1,0);
        dfs2(1,1);
 
        ll ans=0;
        REP(i,1,n) REP(j,i+1,n) if(gcd(val[i],val[j])==1){
            int lca=Lca(i,j);
            ans+=dep[i]+dep[j]-2*dep[lca]; 
        }
        printf("%lld\n",ans);
    }
}p1;
 
struct p60{
    #define NN 10002
    int c[NN][505],cnt1[505],cnt2[505];
    ll dp[NN][505],ans;
    vector<int>prime[505];
     
    void Init(){
        REP(i,2,500){
            int x=i;
            for(int j=2;j<=x;++j){
                if(x%j==0){
                    prime[i].push_back(j);
                    while(x%j==0)x/=j;
                }
            }
        }
    }
     
    void calc(int x){
        memset(cnt1,0,sizeof(cnt1));
        memset(cnt2,0,sizeof(cnt2));
        REP(i,1,Mx) for(int j=1;j*j<=i;++j) {
            if(i%j)continue;
            cnt1[j]+=dp[x][i];
            cnt2[j]+=c[x][i];
            if(i/j!=j) {
                cnt1[i/j]+=dp[x][i];
                cnt2[i/j]+=c[x][i];
            }
        }
    }
     
    void dfs(int x,int f){
        for(int i=head[x];~i;i=E[i].nxt){
            int y=E[i].to;
            if(y==f)continue;
            dfs(y,x);
             
            ll sum1=0,sum2=0;
            REP(j,1,Mx) sum1+=dp[x][j],sum2+=c[x][j];
            calc(x);
              
            REP(j,1,Mx){
                if(!c[y][j])continue;
                int l=(1<<(prime[j].size()));
                ll tot1=0,tot2=0;
                SREP(k,1,l){
                    int tmp=1,t1=0;
                    SREP(p,0,prime[j].size()) if(k&(1<<p))++t1,tmp*=prime[j][p];
                    if(t1&1)tot1+=cnt1[tmp],tot2+=cnt2[tmp];
                    else tot1-=cnt1[tmp],tot2-=cnt2[tmp];
                }
                ans+=(sum1-tot1)*c[y][j]+(sum2-tot2)*(dp[y][j]+c[y][j]);
            }
            REP(j,1,Mx){
                dp[x][j]+=dp[y][j]+c[y][j];
                c[x][j]+=c[y][j];
            }
        }
        calc(x);
        ll sum=0,tot=0;
        REP(j,1,Mx)sum+=dp[x][j];
        int l=(1<<(prime[val[x]].size()));
        SREP(i,1,l){
            int tmp=1,t1=0;
            SREP(j,0,prime[val[x]].size()) if(i&(1<<j))++t1,tmp*=prime[val[x]][j];
            if(t1&1)tot+=cnt1[tmp];
            else tot-=cnt1[tmp];
        }
        ans+=(sum-tot);
        c[x][val[x]]++;
    }
     
    void solve(){
        Init();
        dfs(1,0);
        printf("%lld\n",ans);
    }
}p2;

int dfn[N],lim[N],tim;
bool cmp(int x,int y){return dfn[x]<dfn[y];} 
struct p100{
	
	void dfs1(int x,int f){
		dfn[x]=tim++;
		fa[x]=f;
		dep[x]=dep[f]+1;
		sz[x]=1;
		son[x]=0;
		for(int i=head[x];~i;i=E[i].nxt){
			int y=E[i].to;
			if(y==f)continue;
			dfs1(y,x);
			sz[x]+=sz[y];
			if(sz[son[x]]<sz[y]) son[x]=y;
		}
		lim[x]=tim;
	}
	
	void dfs2(int x,int tp){
		top[x]=tp;
		if(son[x]) dfs2(son[x],tp);
		for(int i=head[x];~i;i=E[i].nxt){
			int y=E[i].to;
			if(y==fa[x] || y==son[x])continue;
			dfs2(y,y);
		}
	}
	
	int Lca(int x,int y){
	    while(top[x]!=top[y]){
	        if(dep[top[x]]<dep[top[y]])swap(x,y);
	        x=fa[top[x]]; 
	    }
	    return dep[x]<dep[y]?x:y;
	}
	
	int A[N],B[N],stk[N];
	int Sz[N];
	vector<int>T[N]; 
	int mu[N];
	
	ll calc(int k){
		int len=0,top=0;
	    for(int i=k;i<N;i+=k) SREP(j,0,T[i].size()) A[len++]=T[i][j];
		sort(A,A+len,cmp);
	    SREP(i,1,len) A[len++]=Lca(A[i-1],A[i]);
	    sort(A,A+len,cmp);
	    len=unique(A,A+len)-A;
	    
	    SREP(i,0,len){
	        int x=A[i];
	        while(top and lim[stk[top-1]]<=dfn[x]) --top;
	        B[x]=stk[top-1];
	        stk[top++]=x;
	    }
	    
	    ll res=0;
	    int tot=0;
	    SREP(i,0,len){
	        Sz[A[i]]=(val[A[i]]%k==0);
	        tot+=Sz[A[i]];
	    }
	    DREP(i,len-1,1){
	        int x=A[i],y=B[x];
	        res+=1ll*(dep[x]-dep[y])*Sz[x]*(tot-Sz[x]);
	        Sz[y]+=Sz[x];
	    }
	    return res;
	}
	
	void solve(){
		dfs1(1,0),dfs2(1,1);
		REP(i,1,n) T[val[i]].push_back(i);
		ll ans=0;
		mu[1]=1;
		SREP(i,1,N) if(mu[i]) {
			for(int j=i+i;j<N;j+=i) mu[j]-=mu[i];
			ans+=calc(i)*mu[i];
		}
		printf("%lld\n",ans);
	}
	
}p3;
 
int main(){
//  	freopen("network.in","r",stdin);
//  	freopen("network.out","w",stdout);
    memset(head,-1,sizeof(head));
    Rd(n);
    REP(i,1,n) Rd(val[i]),chkmax(Mx,val[i]);
    SREP(i,1,n){
        int a,b;
        Rd(a),Rd(b);
        addedge(a,b);
        addedge(b,a);
    }
     
    if(n<=500) p1.solve();
    else if(Mx<=500) p2.solve();
    else p3.solve();
    
    return 0;
}

总结：

  • 感觉大部分时间还是在磨 T 2 T_2 T2​，对于 d p dp dp的转移还是太想当然了，有时候还需要借助其它思想或数据结构来维护，不仅仅是简单的转移。
  • 对于虚树，感觉这又是一个暴力的数据结构，而关键建虚树是要非常明确的知道哪些是有用的点。
Caristra
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
noip 第14场模拟赛
m0_50219534的博客
11-12 346
时间 8:00~8:10 看题，T1感觉是dp，T2期望，T3第一眼感觉是KMP，T4大模拟？ 8:10~9:40 T1，找到了后面的5个一定是在一起的，所以这需要去寻找前面三个的位置，这是dp吗，感觉又不像是，就这样写了前两档，下一档分是a[i]≤50，n≤500000a[i]≤50，n≤500000a[i]≤50，n≤500000，而一共就只要7个，所以50×7=35050×7=35050×7=350，这样就把n减少到了350个，dp可做。最后的一档分就直接贪心的去求，(暴力出奇迹，贪心骗dp)，把后6
NOIP2018模拟卷(2.0).pdf
09-30
这份NOIP2018模拟卷（2.0）针对普及组，主要考察C++编程语言的基础知识以及信息学相关概念。试卷包含了多项选择题、问题求解和程序阅读理解等部分，旨在测试参赛者的逻辑思维、编程基础和问题解决能力。 1. C++中的...
有向图求最小环
Harris-H的博客
11-19 2573
文章目录有向图求最小环方法1floyd方法2dijkstra方法3tarjan方法4 拓扑排序方法5 并查集求环 有向图求最小环 方法1floyd 三重循环扫一遍，然后 rep(i,1,n){ if(d[i][i]==inf) continue; ans=min(ans,d[i][i]); } 时间复杂度：O(n3)O(n^3)O(n3) 方法2dijkstra 对每个结点dijkstradijkstradijkstra一次。 思想与floydfloydfloyd类似。 时间复杂度：O(n(n
【学习笔记】NOIP模拟赛
cqbzlydd的博客
10-16 524
本人大菜鸡一枚，被各种意义上吊打。
【NOIP】XR-4模拟赛，Oler教练的上班策略
weixin_73185295的博客
08-20 162
【NOIP】XR-4模拟赛，Oler教练的上班策略
堆优化的迪杰斯特拉算法
weixin_34268310的博客
04-16 1015
堆优化的迪杰斯特拉 迪杰斯特拉算法 核心代码 rep(i, 1 , n-1){ int minx = inf;//对于每一次找点，都要找当前最短路的点 int pos;//记录一下是哪个点 //**********优化点A************* rep(j , 1 , n){ if(!vis[j] && dis[j] <...
NOIP2018普及组&提高组官方测试数据
11-20
在压缩包“NOIP_评测数据”中，包含了各个级别的测试数据文件，选手可以通过模拟运行自己的程序，将输出与官方提供的答案进行比对，以此来检查程序的正确性。此外，这些数据还可以作为调试和优化程序的依据，帮助...
NOIP2018普及组试题及测试数据
07-31
《NOIP2018普及组试题及测试数据》是一份专门为NOIP（全国青少年信息学奥林匹克联赛）2018年普及组参赛者准备的重要资料。NOIP是中国计算机学会组织的一项面向初中生的信息学竞赛，旨在激发青少年对计算机科学的兴趣...
noip模拟赛day1
10-28
【NOIP模拟赛Day1详解】——为竞赛之路铺砖添瓦 全国青少年信息学奥林匹克联赛（NOIP）是一项旨在发掘和培养青少年编程才能的重要赛事。对于参赛者来说，赛前的充分准备至关重要，尤其是模拟赛的参与，可以帮助考生...
noip提高组模拟题5
07-21
【压缩包子文件的文件名称列表】"BZOJ NoipRound 5"可能表示这是BZOJ（Blue Zoo Online Judge）平台上的第五次NOIP模拟赛。BZOJ是一个在线的编程题解平台，它提供各种编程题目供用户练习，并且支持代码提交和自动...
熊猫人之谜主题模拟赛for noip
04-06
熊猫人之谜主题模拟赛 对于noip的，好像不太难
2015重庆市NOIP模拟赛题目+数据
10-04
2015年10月4日重庆市NOIP模拟赛题目+数据
【题解】NOIP2021模拟赛
cqbzlydd的博客
07-19 1097
A. 状压 dp 。考虑到合并和分裂是互逆操作，所以只需要考虑合并操作。 trick: 将 b[i] 设置为 -b[i] ，题目转化为对一个序列，找到尽量多的和为 0 的集合。暴力转移是 O(3^(n+m)) ，我们考虑优化转移。 注意到 sum=0 时贡献加一，可以设计出如下转移方程 ： dp[i]=max(dp[j]+dp[i-j])+(sum==0),j \in i 时间复杂度 O((n+m)2^(n+m))。 实际优化并不大。 #include<bits/stdc++.h> #defin
运筹学网络模型
qq_55729911的博客
04-20 1098
1.最小生成树 1.1 什么是树？ 如果一个无向连通图不包含回路(连通图中不存在环),那么就是一个树。 如下图所示即为一个数 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pm3hK7WV-1650418044140)(C:\Users\Lin\AppData\Roaming\Typora\typora-user-images\1650351532633.png)] 1.2 什么是最小生成树 最小生成树，顾名思义，就是在某个图结构中进行选取构造，构造出一个树。一个有N个点的图
【NOIP2018模拟赛2018.10.29】
chang_yl的博客
10-29 205
正解 边带权并查集 具体思路，跟一般的边带权并查集一样，一边加入并查集，维护每个点到其根的dis，还没加入的边默认正确，在加入的边中进行判断是否合法。  可以知道，若一次询问两个士兵 (设为l,r) 在一个集合中，为了满足前面的要求，又要满足这次的要求，必须 dis[l] + d == dis[r] ，dis[l]代表l点到根的距离，dis[r]代表r到根的距离，若不满足则一定不合法。  如果两...
NOIP模拟赛2021/11/08
P_Pqueen的博客
11-08 446
NOIP模拟赛2021/11/08比赛时间安排 比赛时间安排 7.50-8.00 t1 感觉只会10分的dfs t2 感觉还是只会dfs啊，直接判断从哪里断 t3 感觉像是个背包（好像就是），不过知道是一道dp题，不想写啊o(╥﹏╥)o t4 心中有暴力的做法，但是算了一下复杂度，太高了，所以先不写 8.00-8.30 t2的暴力写完，枚举从哪里断的时候从后往前枚举，这样分的段数少，说不定还能骗几分（虽然并没有） 8.30-9.05 硬着头皮去写t3了，挑战一下，只写了k=1的情况，然后模仿背包的格式设出数
NOIP2018模拟赛
weixin_30650039的博客
10-23 216
T1 字符串（string） 【题目描述】 定义两个字符串A,B相似当且仅当满足以下两个条件中的至少一个： (1)A和B相同； (2)将A分为长度相同的两个子串A0,A1，将B分为长度相同的两个子串B0,B1，满足A0相似于B0，A1相似于B1或A0相似于B1，A1相似于B0。 给定两个字符串S,T，问它们是否相似。 有多组数据。 【输入数...
雅礼 noip2018 模拟赛 day3 T3
lleozhang的博客
10-22 459
典型树形dp 这里，我们应该看到一些基本性质： ①：如果这个边不能改（不是没有必要改），我们就不改，因为就算改过去还要改回来，显然不是最优的 注意：“不能改”是指边的性质和要求的相同而不包括对边的颜色没有要求的情况！ ②：如果我们每翻转一条边，就认为将这条边的两个端点度数+1，那么不难看到，最后翻转的所有边构成的路径总数就是度数为奇数点个数的1/2 （性质②的证明：一条路径只会对两端...
【NOIP2018模拟赛2018.10.25 B组】
chang_yl的博客
10-25 312
此题爆零。原因不知道可以因费马小定理推出 b' = b MOD p。 可以看出，f(u,p) = v 在这道题里面意思就是 v = u MOD p，由于p是一个质数，那么可以知道所有的a[i]等价于a[i] % p，所有的b[i]等价于b[i] % (p-1) 懒得讲部分分 正解如下： 1、首先我们可以看出处理过后所有的a，b满足 0 &lt;= a &lt;= p-1，0 &lt;= ...
noip模拟赛 测试数据
最新发布
09-13
NOI（全国青少年信息学奥林匹克竞赛）模拟赛的测试数据是指用于评测参赛选手的程序的输入和对应的输出。测试数据是非常重要的，因为它决定了参赛选手的程序能否正确地解决问题。 在NOI模拟赛中，测试数据具有以下特点： 1.充分覆盖：测试数据应涵盖各种可能的输入情况，包括边界条件和极端情况。通过提供不同的测试数据，可以考察选手对问题的全面理解和解决能力。 2.随机性和均衡性：为了公平起见，测试数据应该是随机生成的，而不是针对某个特定算法或解法设计的。同时，测试数据应该是均衡的，即各种情况的概率应该大致相等，以避免偏向某些解法。 3.合理性和可行性：测试数据应该是合理和可行的，即符合题目要求的输入数据，并且是选手能够通过编写程序来处理的。测试数据应该考虑到程序的限制和时间复杂度，以充分测试选手的编程能力。 NOI模拟赛的测试数据通常由经验丰富的考题组负责生成。他们会根据题目的要求和限制，设计出一组合理、充分、随机和均衡的测试数据，以确保参赛选手的程序在各种情况下都能正确运行，并且能通过性能测试。 总之，测试数据在NOI模拟赛中起到了至关重要的作用，它既考察了选手对问题的理解和解决能力，又提高了选手编程的技巧和效率。同时，合理和恰当的测试数据也是公平竞赛的保证，确保每个参赛选手有相同的机会和条件进行竞争。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值