「CSP-S模拟赛」2019第三场

于 2019-12-11 19:57:00 发布
阅读量124 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MachineryCountry/article/details/103676499
版权

「CSP-S模拟赛」2019第二场

这次考试感觉好悲哀啊。
T2T2T2 过掉了，而且居然还跑了 LOJLOJLOJ 上最快的纪录。
结果 T1T1T1 挖穿了…
T3T3T3 一如既往地不可做…

膜拜 JZM\text{JZM}JZM 大佬当场 AAA 掉 T3T3T3（虽然他的 writeint 没开 long longlong\space longlong long 把他自己坑掉了 90pts90pts90pts）
因此再引用一下这句话

十年准备一场空，不开 long longlong\space longlong long 见祖宗

这句话其实是很精辟的。
所以说，#deding int long long 其实是很有用的…

T1 「POI2007」山峰和山谷 Ridges and Valleys

题目

点这里

考场思路（几近正解）

很简单呀，就是跑一边 dfs （其实 bfs 也可以）。
结果我手残多打了一个地方，导致我的算法正确性被自己坑掉了…

#include<cstdio>
// #define FILEOI
#define rep(i,__l,__r) for(int i=__l,i##_end_=__r;i<=i##_end_;++i)
#define dep(i,__l,__r) for(int i=__l,i##_end_=__r;i>=i##_end_;--i)
#define cg (c=getchar())
template<class T>inline void qread(T& x){
	x=0;char c;bool f=0;
	while(cg<'0'||'9'<c)if(c=='-')f=1;
	for(x=(c^48);'0'<=cg&&c<='9';x=(x<<1)+(x<<3)+(c^48));
	if(f)x=-x;
}
template<class T,class... Args>inline void qread(T& x,Args&... args){qread(x),qread(args...);}
inline int qread(){
	int x=0;char c;bool f=1;
	while(cg<'0'||'9'<c)if(c=='-')f=0;
	for(x=(c^48);'0'<=cg&&c<='9';x=(x<<1)+(x<<3)+(c^48));
	return f?x:-x;
}
#undef cg
template<class T>inline T Max(const T x,const T y){return x>y?x:y;}
template<class T>inline T Min(const T x,const T y){return x<y?x:y;}
template<class T>inline T fab(const T x){return x>0?x:-x;}
template<class T>void fwrit(T x){
	if(x<0)return (void)(putchar('-'),fwrit(-x));
	if(x>10)fwrit(x/10);
	return (void)(putchar(x%10^48));
}

const int MAXN=1e3;
const int chkDir[][2]={{0,1},{0,-1},{1,0},{-1,0}};
const int scDir[][2]={{0,1},{0,-1},{1,0},{-1,0},{1,-1},{1,1},{-1,1},{-1,-1}};

int w[MAXN+5][MAXN+5],n,tot0,tot1;
bool vis[MAXN+5][MAXN+5];

inline void init(){
	qread(n);
	rep(i,1,n)rep(j,1,n)qread(w[i][j]);
}

inline bool inside(const int x,const int y){
	return 0<x&&x<=n&&0<y&&y<=n;
}

inline bool check(const int x,const int y,const bool f){
//若 f 为 1, 则检测四周不能大于它
//若 f 为 0, 则检测四周不能小于它
	int tx,ty;
	if(f){
		rep(i,0,7){
			tx=x+scDir[i][0],ty=y+scDir[i][1];
			if(inside(tx,ty)&&w[tx][ty]>w[x][y])return false;
		}
	}
	else{
		rep(i,0,7){
			tx=x+scDir[i][0],ty=y+scDir[i][1];
			if(inside(tx,ty)&&w[tx][ty]<w[x][y])return false;
		}
	}
	return true;
}

inline bool dfs(const int x,const int y,const bool f){
	vis[x][y]=true;
	int tx,ty;bool ret=true;
	rep(i,0,7){
		tx=x+scDir[i][0],ty=y+scDir[i][1];
		if(!inside(tx,ty)||w[tx][ty]!=w[x][y]||vis[tx][ty])continue;
		ret=ret&check(tx,ty,f);
		ret=ret&dfs(tx,ty,f);
	}
	return ret;
}

inline void algor(){
	rep(i,1,n)rep(j,1,n)if(!vis[i][j]){
		if(!check(i,j,0)&&!check(i,j,1)){//这个地方有问题...
			vis[i][j]=true;
			continue;
		}
		if(check(i,j,0)&&dfs(i,j,0))++tot0;
		if(check(i,j,1)&&dfs(i,j,1))++tot1;
	}
}

signed main(){
#ifdef FILEOI
	freopen("mountain.in","r",stdin);
	freopen("mountain.out","w",stdout);
#endif
	init();
	algor();
	printf("%d %d\n",tot1,tot0);
	return 0;
}

正解

其实就是这个代码，去掉一个点（代码中有标记）。
为什么呢？因为如果我将这个点标记上 truetruetrue，那么后面的搜索可能会排除掉这个有问题的点而被计入答案。
将其去掉即可。

#include<cstdio>
// #define FILEOI
#define rep(i,__l,__r) for(int i=__l,i##_end_=__r;i<=i##_end_;++i)
#define dep(i,__l,__r) for(int i=__l,i##_end_=__r;i>=i##_end_;--i)
#define cg (c=getchar())
template<class T>inline void qread(T& x){
	x=0;char c;bool f=0;
	while(cg<'0'||'9'<c)if(c=='-')f=1;
	for(x=(c^48);'0'<=cg&&c<='9';x=(x<<1)+(x<<3)+(c^48));
	if(f)x=-x;
}
template<class T,class... Args>inline void qread(T& x,Args&... args){qread(x),qread(args...);}
inline int qread(){
	int x=0;char c;bool f=1;
	while(cg<'0'||'9'<c)if(c=='-')f=0;
	for(x=(c^48);'0'<=cg&&c<='9';x=(x<<1)+(x<<3)+(c^48));
	return f?x:-x;
}
#undef cg
template<class T>inline T Max(const T x,const T y){return x>y?x:y;}
template<class T>inline T Min(const T x,const T y){return x<y?x:y;}
template<class T>inline T fab(const T x){return x>0?x:-x;}
template<class T>void fwrit(T x){
	if(x<0)return (void)(putchar('-'),fwrit(-x));
	if(x>10)fwrit(x/10);
	return (void)(putchar(x%10^48));
}

const int MAXN=1e3;
const int chkDir[][2]={{0,1},{0,-1},{1,0},{-1,0}};
const int scDir[][2]={{0,1},{0,-1},{1,0},{-1,0},{1,-1},{1,1},{-1,1},{-1,-1}};

int w[MAXN+5][MAXN+5],n,tot0,tot1;
bool vis[MAXN+5][MAXN+5];

inline void init(){
	qread(n);
	rep(i,1,n)rep(j,1,n)qread(w[i][j]);
}

inline bool inside(const int x,const int y){
	return 0<x&&x<=n&&0<y&&y<=n;
}

inline bool check(const int x,const int y,const bool f){
//若 f 为 1, 则检测四周不能大于它
//若 f 为 0, 则检测四周不能小于它
	int tx,ty;
	if(f){
		rep(i,0,7){
			tx=x+scDir[i][0],ty=y+scDir[i][1];
			if(inside(tx,ty)&&w[tx][ty]>w[x][y])return false;
		}
	}
	else{
		rep(i,0,7){
			tx=x+scDir[i][0],ty=y+scDir[i][1];
			if(inside(tx,ty)&&w[tx][ty]<w[x][y])return false;
		}
	}
	return true;
}

inline bool dfs(const int x,const int y,const bool f){
	vis[x][y]=true;
	int tx,ty;bool ret=true;
	rep(i,0,7){
		tx=x+scDir[i][0],ty=y+scDir[i][1];
		if(!inside(tx,ty)||w[tx][ty]!=w[x][y]||vis[tx][ty])continue;
		ret=ret&check(tx,ty,f);
		ret=ret&dfs(tx,ty,f);
	}
	return ret;
}

inline void algor(){
	rep(i,1,n)rep(j,1,n)if(!vis[i][j]){
		if(check(i,j,0)&&dfs(i,j,0))++tot0;
		if(check(i,j,1)&&dfs(i,j,1))++tot1;
	}
}

signed main(){
#ifdef FILEOI
	freopen("mountain.in","r",stdin);
	freopen("mountain.out","w",stdout);
#endif
	init();
	algor();
	printf("%d %d\n",tot1,tot0);
	return 0;
}

T2 「JOI 2013 Final」 现代豪宅

题目

点这里

考场思路（正解）

稍作分析，即可看出这是一个图论题。
将同行同列的点建边连起来，最后特判开始和结束即可，这个题直接看代码，其实还是很清晰的。

#include<cstdio>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
// #define FILEOI
#define int long long
#define rep(i,__l,__r) for(int i=__l,i##_end_=__r;i<=i##_end_;++i)
#define dep(i,__l,__r) for(int i=__l,i##_end_=__r;i>=i##_end_;--i)
#define cg (c=getchar())
template<class T>inline void qread(T& x){
	x=0;char c;bool f=0;
	while(cg<'0'||'9'<c)if(c=='-')f=1;
	for(x=(c^48);'0'<=cg&&c<='9';x=(x<<1)+(x<<3)+(c^48));
	if(f)x=-x;
}
template<class T,class... Args>inline void qread(T& x,Args&... args){qread(x),qread(args...);}
inline int qread(){
	int x=0;char c;bool f=1;
	while(cg<'0'||'9'<c)if(c=='-')f=0;
	for(x=(c^48);'0'<=cg&&c<='9';x=(x<<1)+(x<<3)+(c^48));
	return f?x:-x;
}
#undef cg
template<class T>inline T Max(const T x,const T y){return x>y?x:y;}
template<class T>inline T Min(const T x,const T y){return x<y?x:y;}
template<class T>inline T fab(const T x){return x>0?x:-x;}
template<class T>void fwrit(T x){
	if(x<0)return (void)(putchar('-'),fwrit(-x));
	if(x>10)fwrit(x/10);
	return (void)(putchar(x%10^48));
}

const int MAXN=1e5;
const int MAXK=2e5;

int M,N,K,s,t;bool sp,tp;

struct node{
	int x,y,id;
	node(){}
	node(const int X,const int Y,const int I):x(X),y(Y),id(I){}
};
inline bool cmpx(const node tt,const node t){return tt.x<t.x;}
inline bool cmpy(const node tt,const node t){return tt.y<t.y;}

vector<node>n[MAXN+5];
vector<node>m[MAXN+5];

struct edge{
	int to,nxt,d,w;
	edge(){}
	edge(const int T,const int N,const int D,const int W):to(T),nxt(N),d(D),w(W){}
}e[(MAXK<<3)+5];
int tail[MAXK+5],ecnt;
inline void add_edge(const int u,const int v,const int d,const int w){
	e[++ecnt]=edge(v,tail[u],d,w);tail[u]=ecnt;
	e[++ecnt]=edge(u,tail[v],d,w);tail[v]=ecnt;
}

inline void init(){
	qread(M,N,K);
	int x,y;
	for(int i=1;i<=K;++i){qread(x,y);
		if(x==1&&y==1)sp=true,s=i;
		if(x==M&&y==N)tp=true,t=i;
		m[x].push_back(node(x,y,i));
		n[y].push_back(node(x,y,i));
	}
	return;
}

inline void buildGragh(){
	for(int i=1;i<=M;++i)if(m[i].size()>1){
		sort(m[i].begin(),m[i].end(),cmpy);
		for(int j=1,siz=m[i].size();j<siz;++j)
			add_edge(m[i][j-1].id,m[i][j].id,m[i][j].y-m[i][j-1].y,1);
	}
	for(int i=1;i<=N;++i)if(n[i].size()>1){
		sort(n[i].begin(),n[i].end(),cmpx);
		for(int j=1,siz=n[i].size();j<siz;++j)
			add_edge(n[i][j-1].id,n[i][j].id,n[i][j].x-n[i][j-1].x,0);
	}
	if(!sp){
		s=0;
		if(!m[1].empty())add_edge(s,m[1][0].id,m[1][0].y-1,1);
	}
	if(!tp){
		t=K+1;
		if(!n[N].empty())add_edge(t,n[N][n[N].size()-1].id,M-n[N][n[N].size()-1].x,0);
		if(!m[M].empty())add_edge(t,m[M][m[M].size()-1].id,N-m[M][m[M].size()-1].y,1);
	}
}

const int INF=(1ll<<50);
int dis[MAXK+5];
struct info{
	int u,d,w;
	info(){}
	info(const int U,const int D,const int W):u(U),d(D),w(W){}
	bool operator<(const info a)const{return !(d<a.d);}
};
priority_queue<info>Q;
inline void dijkstra(){
	rep(i,0,K+1)dis[i]=INF;
	dis[s]=0;
	Q.push(info(s,0,1));
	while(!Q.empty()){
		info now=Q.top();Q.pop();
		// printf("Now : %lld %lld %lld\n",now.u,now.d,now.w);
		if(now.d>dis[now.u])continue;
		for(int i=tail[now.u],v,w;i;i=e[i].nxt){
			v=e[i].to;
			w=now.d+e[i].d+(now.w!=e[i].w);
			if(w<dis[v]){
				dis[v]=w;
				if(v!=t)Q.push(info(v,w,e[i].w));
			}
		}
	}
}

signed main(){
#ifdef FILEOI
	freopen("mansion.in","r",stdin);
	freopen("mansion.out","w",stdout);
#endif
	init();
	buildGragh();
	dijkstra();
	if(dis[t]==INF)printf("-1\n");
	else printf("%lld\n",dis[t]);
	return 0;
}

T3 「SCOI2015」小凸玩密室

题目

点这里

考场思路

题目读错了，导致我暴力都打不出来…
其实题目要求的是一定要将某一棵子树全部扫完再去扫其他的子树。
而不是左边扫一下，右边扫一下…

正解

首先，这里补充一个数据范围 （考试的时候也有）

对于 10%10\%10% 的数据，1≤n≤101≤n≤101≤n≤10；
另有 10%10\%10% 的数据， 1≤n≤201≤n≤201≤n≤20 ；
另有 10%10\%10% 的数据， 1≤n≤20001≤n≤20001≤n≤2000 ；
另有 20%20\%20% 的数据， 1≤n≤200001≤n≤200001≤n≤20000 ；
对于 100%100\%100% 的数据， 1≤n≤2×1051≤n≤2\times 10^51≤n≤2×105 ， 1≤Ai≤1051≤A_i≤10^51≤Ai​≤105 ， 1≤Bi≤1051≤B_i≤10^51≤Bi​≤105 。

再次引用这句话 虽然是我自己编的

所谓信息竞赛，其实就是面向数据编程

其实，根据数据范围，一步一步想出算法并优化其实也是一个解题的好方法。

子方案 1 (10pts)

首先，看前 10%10\%10% 的数据，这个地方我们可以怎么做呢？
这样的暴力其实很简单，用 O(n!)O(n!)O(n!) 枚举我们访问的顺序。
再判断这个顺序是否合法，最后计算花费即可。

子方案 2 (20pts)

但是很明显，对于 10pts10pts10pts 的算法，是过不了第二个 10pts10pts10pts 的数据点的。
怎么进行优化？
注意到子方案 111 中有这样的操作：
随意枚举顺序，再判断是否合法。
这样做让我们用很多时间枚举了很多不合法的访问顺序。
那么我们是否可以让我们枚举的序列本来就合法，只需直接去算花费？
这是肯定可以的，时间复杂度 O(2n)O(2^n)O(2n)，因为我们要分左、右儿子去构造访问顺序。
这样，时间复杂度应该是 O(n2n⋅nlog2n)O(n2^n\cdot nlog^n_2)O(n2n⋅nlog2n​)。

子方案 3 (50pts)

对于子方案 222 的优化显然是很好的，但是这都基于 暴力 这一思想，接下来我们需要转换思路。
考虑我们是怎么点亮一个子树的。
对于一个子树，它的根是 uuu，左儿子是 lclclc，右儿子是 rcrcrc。
假若我们先访问左子树，先不管它是怎么访问的。
那么，我们在左子树里面的访问顺序是否对后面的状态有影响？
是有的，证明如下： 本人数学不好，没有严格数学书写顺序
假设我们在左子树里面的访问顺序中的某一种是以 xxx 结尾。
很显然这个 xxx 有很多个。
而当我们从左子树到右子树去的时候，先要访问右子树的树根，即 rcrcrc。
那么这个花费显然是 dis(x,rc)∗A[rc]dis(x,rc)*A[rc]dis(x,rc)∗A[rc]。
而又因为这个 xxx 有很多个，那么很显然。不同的 xxx 是会有不同的花费。
因而左子树里面的访问顺序是对后面的状态有影响。
而且很显然，对后面状态有影响的只有最后访问的那个点在哪里。
所以，我们就可以定义状态 f[u][x]f[u][x]f[u][x] 为访问完以 uuu 为根的子树（不包含 uuu）且结尾在 xxx 时的最小花费。
那么，就可以分类进行状转：

  • 当 xxx 在左子树上时，f[u][y]=min{dis(u,lc)×A[lc]+f[lc][x]+dis(x,rc)×A[rc]+f[rx][y]}f[u][y]=min\{dis(u,lc)\times A[lc]+f[lc][x]+dis(x,rc)\times A[rc]+f[rx][y]\}f[u][y]=min{dis(u,lc)×A[lc]+f[lc][x]+dis(x,rc)×A[rc]+f[rx][y]}
  • 当 xxx 在右子树上时，f[u][y]=min{dis(u,rc)×A[rc]+f[rc][x]+dis(x,lc)×A[lc]+f[lc][y]}f[u][y]=min\{dis(u,rc)\times A[rc]+f[rc][x]+dis(x,lc)\times A[lc]+f[lc][y]\}f[u][y]=min{dis(u,rc)×A[rc]+f[rc][x]+dis(x,lc)×A[lc]+f[lc][y]}

很显然，状转中 x、yx、yx、y 都是需要循环枚举的，因而这个状转大概是 O(n2)O(n^2)O(n2) 的复杂度。
所以总复杂度是 O(n3)O(n^3)O(n3)。
但其实这样的计算是不准确的，准确复杂度应该是 ∑n22x+2\sum\frac{n^2}{2^{x+2}}∑2x+2n2​。
这个复杂度是通过分层计算得出。
不难看出，这个复杂度可得到 50pts50pts50pts 的高分。

子方法 4 (正解)

我们发现，对于子方法三，其实已经快要过掉这道题了。
但是哪里的时间复杂度较高呢？
毋庸置疑的，状转的 O(n2)O(n^2)O(n2) 其实已经非常高了。
怎么减下来？肯定是要针对其状转简化。
观察状转：

  • 当 xxx 在左子树上时，f[u][y]=min{dis(u,lc)×A[lc]+f[lc][x]+dis(x,rc)×A[rc]+f[rx][y]}f[u][y]=min\{dis(u,lc)\times A[lc]+f[lc][x]+dis(x,rc)\times A[rc]+f[rx][y]\}f[u][y]=min{dis(u,lc)×A[lc]+f[lc][x]+dis(x,rc)×A[rc]+f[rx][y]}
  • 当 xxx 在右子树上时，f[u][y]=min{dis(u,rc)×A[rc]+f[rc][x]+dis(x,lc)×A[lc]+f[lc][y]}f[u][y]=min\{dis(u,rc)\times A[rc]+f[rc][x]+dis(x,lc)\times A[lc]+f[lc][y]\}f[u][y]=min{dis(u,rc)×A[rc]+f[rc][x]+dis(x,lc)×A[lc]+f[lc][y]}

我们先考虑其中一个状转，另一个其实是对应的。
拿第一个算式来说
f[u][y]=min{dis(u,lc)×A[lc]+f[lc][x]+dis(x,rc)×A[rc]+f[rx][y]}f[u][y]=min\{dis(u,lc)\times A[lc]+f[lc][x]+dis(x,rc)\times A[rc]+f[rx][y]\}f[u][y]=min{dis(u,lc)×A[lc]+f[lc][x]+dis(x,rc)×A[rc]+f[rx][y]}考虑将其分解：
对于 dis(x,rc)dis(x,rc)dis(x,rc) ，其实不难看出
dis(x,rx)=dis(x,u)+dis(u,rc)dis(x,rx)=dis(x,u)+dis(u,rc)dis(x,rx)=dis(x,u)+dis(u,rc)而这里面，只有 dis(x,u)dis(x,u)dis(x,u) 是改变的。
那么我们只需将 dis(x,u)dis(x,u)dis(x,u) 也存入状态中，就可以同时考虑它的最小值了。
所以，访问一边的最小花费就是
ans2=f[lc][x]+dis(u,rc)×A[rc]+[dis(u,x)+dis(u,rc)]×A[rc]ans2=f[lc][x]+dis(u,rc)\times A[rc]+[dis(u,x)+dis(u,rc)]\times A[rc]ans2=f[lc][x]+dis(u,rc)×A[rc]+[dis(u,x)+dis(u,rc)]×A[rc]最后的花费，就是 ans2+f[lc][x]ans2+f[lc][x]ans2+f[lc][x] 了。
最后，根据这个 xxx 到底在左边还是在右边进行分类转移即可。
但是，这就是最后的答案了吗？
肯定不是，题目并未要求我们必须从 111 开始。
所以，定义另一个状态 t[i][j]t[i][j]t[i][j]：访问完 iii 的子树，结尾在 jjj 时的最小花费。
那么这个怎么转移呢？
这里可以自行思考了
如果还是想不出来，看看代码吧，看看代码总有好处的
std version

#include<bits/stdc++.h>
#define mz 1000000007
using namespace std;

long long inf=mz*1LL*mz;
long long dep[200005];
int n,a[200005],b[200005];
vector <long long> dp[200005],dis[200005],dpp[200005];

void dfs(int x)
{
    dep[x]=dep[x/2]+b[x];//计算伪深度, 方便计算距离
    if(x*2<=n)//有左儿子
    {
        dfs(x*2);//先访问左儿子
        int t=dp[x*2].size();//得到左儿子的叶子共有多少个
        if(x*2+1<=n)//如果有右儿子
        {
            dfs(x*2+1);//访问右儿子
            long long ans1=inf,ans2=inf,ansp1=inf,ansp2=inf;
            //分别是 f, t
            for(int i=0;i<dp[x].size();i++)
            {
                if(i<t)//如果这个点是左子树上的点
                {

                    ans1=min(ans1,dp[x*2][i]+1LL*b[x*2]*a[x*2]+(dis[x][i]+b[x*2+1])*a[x*2+1]);
                    ansp1=min(ansp1,dpp[x*2][i]+dis[x][i]*a[x]+1LL*b[x*2+1]*a[x*2+1]);
                }
                else//当这个点是右子树上的点
                {
                    ans2=min(ans2,dp[x*2+1][i-t]+1LL*b[x*2+1]*a[x*2+1]+(dis[x][i]+b[x*2])*a[x*2]);
                    ansp2=min(ansp2,dpp[x*2+1][i-t]+dis[x][i]*a[x]+1LL*b[x*2]*a[x*2]);
                }
            }
            for(int i=0;i<dp[x].size();i++)
            {
                if(i<t)//如果它是左儿子
                {
                    dp[x][i]=ans2+dp[x*2][i];
                    dpp[x][i]=min(dp[x][i],ansp2+dp[x*2][i]);
                }
                else//是右儿子
                {
                    dp[x][i]=ans1+dp[x*2+1][i-t];
                    dpp[x][i]=min(dp[x][i],ansp1+dp[x*2+1][i-t]);
                }
            }
        }
        else//没有右儿子
        {
            for(int i=x;i>=1;i=i/2)
            {
                dp[i].push_back(0);
                dpp[i].push_back(0);
                dis[i].push_back(dep[x]-dep[i]);
            }
            dp[x][0]=1LL*b[x*2]*a[x*2];
            dpp[x][0]=inf;
            dp[x][1]=inf;
            dpp[x][1]=1LL*b[x*2]*a[x];
        }
    }
    else//没有后辈
    {
        for(int i=x;i>=1;i=i/2)
        {
            dp[i].push_back(0);
            dpp[i].push_back(0);
            dis[i].push_back(dep[x]-dep[i]);
        }
    }
}

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    for(int i=2;i<=n;i++)
        scanf("%d",&b[i]);
    dfs(1);
    long long ans=inf;
    for(int i=0;i<dp[1].size();i++)
        ans=min(ans,dpp[1][i]);
    printf("%lld\n",ans);
    return 0;
}
Arextre
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
5、2019 CSP-S1 模拟赛3-主办方模拟测试题.PDF.pdf
10-08
5、2019 CSP-S1 模拟赛3-主办方模拟测试题.PDF.pdf
3、CSP-J第一轮学军信友队开放模拟赛_题解.pdf
10-08
3、CSP-J第一轮学军信友队开放模拟赛_题解.pdf
提高组难度模拟赛.pdf
06-13
三道题考察暴力/树上倍增/矩阵乘法. 对冲刺NOIP提高组的你提供有效助力.
【CSP-S2019模拟】09.13比赛总结
Deep_Thinking的博客
09-13 502
暴力又又又又挂了，不对拍见祖宗 比赛思路 传送门 T1（ca）：刚开始想将它变成二进制数的生成，后来发现还没有树形结构简单。直接设f[n][m]为答案，枚举左子树的叶子个数，n3转移就有35分了。 T2（tiring）：根据周期拆点，直接最短路就好了，着实很淼 T3（pe）：神仙题，最后n2暴力。 赛后消化 T1题解： T2SPFA死了，考场上想过加一个队首换队头的优化，但是想到可能没有什么...
CSP-J模拟赛附答案
08-12
CSP-J模拟赛CSP-J模拟赛CSP-J模拟赛CSP-J模拟赛CSP-J模拟赛CSP-J模拟赛CSP-J模拟赛CSP-J模拟赛CSP-J模拟赛CSP-J模拟赛CSP-J模拟赛CSP-J模拟赛CSP-J模拟赛CSP-J模拟赛CSP-J模拟赛CSP-J模拟赛CSP-J模拟赛CSP-J模拟赛...
CSP-J CSP-S初赛模拟题_PDF(2020.10.09).rar
10-09
CSP-J CSP-S初赛模拟题_PDF(2020.10.09) CSP-J CSP-S初赛模拟题_PDF(2020.10.09) CSP-J CSP-S初赛模拟题_PDF(2020.10.09) CSP-J CSP-S初赛模拟题_PDF(2020.10.09) CSP-J CSP-S初赛模拟题_PDF(2020.10.09)
CSP-J模拟赛：真题复现
08-02
考试试卷
40、CSP-S 模拟试题试卷 problem(含水印).pdf
10-11
40、CSP-S 模拟试题试卷 problem(含水印).pdf
CSP2019模拟赛B
IDDFS
10-25 350
题目大意 有一个由NNN条边构成的正多边形，要求选出MMM个顶点并将这些点顺次连起来，使得构成的多边形有恰好KKK个锐角，求方案数。 分析 显然的容斥原理 Part1. 有锐角的条件 根据我们学过的初中数学知识，我们可以知道： 不可能有一个多边形出现多于三个锐角； 正多边形的各个顶点一定共圆； 等弦对等角。 我们简单画一下图就可以发现，当我们在圆上任意取三个点A,B,CA,B,CA,B,C时，...
「CSP-S模拟赛」2019第四场
MachineryCountry的博客
11-14 208
「CSP-S模拟赛」2019第四场T1 「JOI 2014 Final」JOI 徽章题目考场思考（正解）T2 「JOI 2015 Final」分蛋糕 2题目考场思考（正解）T3 「CQOI2014」数三角形题目考场思考正解 这场考试还是同一个感觉：听音乐误事啊… 把 T1、T2T1、T2T1、T2 码出来之后，听音乐听到不想做题，但是 T3T3T3 又是一个注重思考的题…然后，我暴力都没码出来。...
2019.11.12CSP-S模拟赛 a b c
cqbzcsq的博客
11-13 241
a 时限:2Sec内存:512 MB 题目描述 输入格式 输入样例 6 4 2 2 4 2 5 输出样例 6 提示 题解 想了30min 如果把i看成x坐标，si看成y坐标 发现就是快速维护在直线y=x-i下方的点的个数 如果直线向左移动一位 则直线下方的点会对答案造成-1的贡献，上方的点会对答案造成+1的贡献（两端的贡献...
【CSP-S2019模拟】11.01比赛模拟
Deep_Thinking的博客
11-01 337
日均挂50分 比赛思路 传送门 T1（森林）：如果是加的话就倒着变成删。排序后贪心就好了。 T2（玩具）：理解题意之后发现并不是很好做，先做了T3。推了一波DP，发现中间的标号会算重，又加了一维，原本n3的就变成n4了。 T3（飘雪圣城）：求边数。刚开始以为是可持久化线段树。打的时候发现直接用树状数组就可以维护了，然后就又短又水了。 赛后消化 T1因为会加入一些房子，数组要开大两倍。。。还好...
[CSP-S 2019 day2 T2] 划分
DD(XYX)的硫氰化氘博客
11-22 930
题面 题解 CSP赛场上能请教别人吗 在这道题中，我看到了一个很敏感又很熟悉的东西——平方！ 这意味着，可以推出一些结论，使这道题几乎可以边输入边解决。 自己在脑子里动态一下就知道，像这种总和一定、代价为平方的模式一眼就可以看出这个明显的结论：最大的段最小 ！ （可惜笔者做到后来把它忘了） 于是，我们就可以把一个总和一定的一个序列，使它的最后一段的和最小。 令f[i...
「CSP-S模拟赛」2019第二场
MachineryCountry的博客
11-12 175
「CSP-S模拟赛」2019第二场T1 Jam的计数法题目考场思路（正解）T2 「TJOI / HEOI2016」排序题目考场思路（假正解）正解T3 「THUWC 2017」随机二分图题目考场思路正解 这场考试的数据感觉很水。 T1T1T1 签到不解释，T2T2T2 期望 50pts50pts50pts 结果有 100pts100pts100pts，T3T3T3 一如既往地不可做… T1 Ja...
【CSP-S 2019模拟】题解
Stargazer的博客
11-02 134
T1： O(n2)O(n^2)O(n2)枚举后用逆元算第三个即可 用hash tablehash\ tablehash table存即可 脑残写了个奇奇妙妙的n2logn^2logn2log wa3\ wa3 wa3个T3T3T3个 #include<bits/stdc++.h> using namespace std; #define cs c...
【CSP-S2019模拟】09.25比赛总结
Deep_Thinking的博客
09-26 278
T1的出题人祝您身体健康 比赛思路 传送门 T1（化学）：刚开始看到“烷烃”就懵逼了，一看六页的题面以为是毒瘤的题答题，仔细读懂后原来是模拟题，十几种特判实际上是码农题，只用找重链等简单操作，我读题意读了40+min，总共打了2.5小时（意志坚定），获得了80分的好成绩。 T2（工厂）：显然是DP，显然要找性质划分状态，然后。。。我找不出来。 T3（质树）：真的没时间了。还是部分分吧。 赛后消...
关于__Federico Milano 的电力系统分析工具箱.zip
最新发布
04-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
csp-j+csp-s新题型初赛模拟试题附答案
08-01
这个问题中提到的是 csp-j csp-s 新题型初赛模拟试题附答案。具体的试题内容我无法提供，因为每届竞赛的试题都是新的，为了保证公平性，试题一般不会提前公布。也就是说，我无法提供 csp-j csp-s 新题型初赛模拟试题...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值