CSP 202212题解：现值计算，训练计划，JPEG 解码，聚集方差，星际网络

已于 2023-03-08 16:36:19 修改
阅读量2.2k 收藏 10
点赞数 5
分类专栏： CSP专业组题解 文章标签： 算法 c++ 开发语言
于 2023-03-08 16:33:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fmy_xfk/article/details/129353286
版权

试题内容请前往CCF官网查看：

CCF-CSP计算机软件能力认证考试
http://118.190.20.162/home.page

这是一份以C++代码编写的CSP 专业组 202212题解。

阅读本题解前，您应当了解下列知识：

  1. 树 教程
  2. 树链剖分(轻重链剖分) 教程
  3. 树上启发式合并 教程

请注意这不是CSP-S/J的中学生竞赛的题解。

现将模拟测试系统中的得分列举如下：

题目得分时间内存
现值计算10015ms3.136MB
训练计划10015ms2.988MB
JPEG 解码10015ms2.921MB
聚集方差1001.828s192.9MB
星际网络---

最后一题还没有看，日后更新。

1. 现值计算

提示很充足，按照提示完成题目即可。

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

int main(){
	int n;double s,r,x;
	cin>>n>>r>>s;
	for(int i=1;i<=n;++i){
		cin>>x;
		s+=x*pow(1+r,-i);
	}
	cout<<s<<endl;
	return 0;
}

2. 训练计划

训练计划构成一棵树。最早开始时间从根往叶子递推。最迟开始时间从从叶子往根递推，也就递归求解。

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

const int MAXN=370,MAXM=110;
bool vis[MAXN];
int early[MAXM],late[MAXM],p[MAXM],t[MAXM],n;
vector<int> gl[MAXM];

int check_early(int i){
	if(early[i]) return early[i];
	if(p[i]==0) return early[i]=1;
	return early[i]=check_early(p[i])+t[p[i]];
}

int check_late(int i){
	if(i==0) return n+1;
	if(late[i]<=n) return late[i];
	int lt=n+1;
	for(auto ch:gl[i]){lt=min(lt,check_late(ch));}
	return late[i]=lt-t[i];
}

int main(){
	int m,x;
	cin>>n>>m;
	for(int i=1;i<=m;++i){
		cin>>p[i];
		if(p[i])gl[p[i]].push_back(i);
	}
	for(int i=1;i<=m;++i)cin>>t[i],late[i]=n+1;
	late[0]=n+1;
	for(int i=1;i<=m;++i)check_early(i);
	for(int i=1;i<=m;++i)cout<<early[i]<<" ";
	cout<<endl;
	bool f=true;
	for(int i=1;i<=m;++i)
		if(check_late(i)<=0){
			f=false;break;
		}
	if(f){
		for(int i=1;i<=m;++i)cout<<late[i]<<" ";
		cout<<endl;
	}
	return 0;
}

3. JPEG 解码

大型模拟题，没有什么难度，照做即可。

值得一提的是蛇形输入，这个稍微动动脑筋。实在不行打个表，指示每个数的输入位置，毕竟只有8x8=64个格子。

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

const double pi8=acos(-1)/8.0;
double alpha(int u){return u==0?sqrt(0.5):1;}
int cast(int x){
	if(x<0) return 0;
	if(x>255) return 255;
	return x;
}

class matrix{
	int a[8][8];
public:
	matrix(){
		for(int i=0;i<8;++i)
			for(int j=0;j<8;++j)
				a[i][j]=0;
	}
	void read_mat(){
		for(int i=0;i<8;++i)
			for(int j=0;j<8;++j)
				cin>>a[i][j];
	}
	void read_scan_data(int n){
		int i=0,j=0,k=1;
		while(n--){
			cin>>a[i][j];
			if(k==1)
				if(j==7) ++i,k=-1;
				else if(i==0) ++j,k=-1;
				else --i,++j;
			else//k==-1
				if(i==7) ++j,k=1;
				else if(j==0) ++i,k=1;
				else ++i,--j;
		}
	}
	matrix& operator*=(matrix &m){
		for(int i=0;i<8;++i)
			for(int j=0;j<8;++j)
				a[i][j]*=m.a[i][j];
		return (*this);
	}
	matrix idct(){
		matrix ret;
		for(int i=0;i<8;++i){
			for(int j=0;j<8;++j){
				double s=0;
				for(int u=0;u<8;++u)
					for(int v=0;v<8;++v)
						s+=alpha(u)*alpha(v)*a[u][v]*cos(pi8*(i+0.5)*u)*cos(pi8*(j+0.5)*v);

				ret.a[i][j]=cast(round(s/4.0+128));
			}
		}
		return ret;
	}
};
int main(){
	matrix q,m;
	q.read_mat();
	int n;cin>>n;
	int T;cin>>T;
	m.read_scan_data(n);
	if(T==0){m.print();return 0;}
	m*=q;
	if(T==1){m.print();return 0;}
	m.idct().print();
	return 0;
}

4. 聚集方差

子任务1,2： 对于一棵子树，我们维护一个map，指示其中每种数有几个，然后计算“聚集方差”即可。向上递推时，暴力合并几个子树再加一个根节点。时间复杂度 O ( n 2 log ⁡ n ) O(n^2\log n) O(n2logn)（ log ⁡ \log log是由map查询操作带来的），可得40分。

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

typedef long long ll;
ll sqr(int x){return (ll)x*x;}
const int MAXN=3e5+10;

struct sta{
	int min_dist,count;
	sta():min_dist(-1),count(1){}
	sta(int md,int cnt):min_dist(md),count(cnt){}
	void inc(int c=1){count+=c;if(count>=2) min_dist=0;}
};

typedef map<int,sta> dict;
typedef dict::iterator dictit;

class statistics{//个数统计器 
	int cnt;ll ga;
	dict mp;
	int __1st() {return mp.begin()->first;}//得到map中的第一个数
	pair<vector<int>,vector<dictit> > __dist(dictit it) {//对于给定的数，计算它的最小距离，以及左右2个数的最小距离
		vector<int> ret;vector<dictit> retp(3,mp.end());
		int x=it->first,d=INT_MAX;
		if(it==mp.begin()){
			ret.push_back(-1);
		}else{
			auto itl=it;--itl;
			if(x-itl->first<d){
				d=x-itl->first;
				retp[2]=itl;
			}
			ret.push_back(itl->second.min_dist);
			retp[0]=itl;
		}
		auto end=mp.end();--end;
		if(it==end){
			ret.push_back(-1);
		}else{
			auto itr=it;++itr;
			if(itr->first-x<d){
				d=itr->first-x;
				retp[2]=itr;
			}
			ret.push_back(itr->second.min_dist);
			retp[1]=itr;
		}
		ret.push_back(d);
		return {ret,retp};//{左侧数的最小距离，右侧数的最小距离，该数的最小距离},{左侧数的迭代器，右侧数的迭代器，最小距离对应数的迭代器}
	}
public:
	statistics(int x):cnt(1),ga(0){mp[x]=sta(-1,1);}
	void insert(int x,int x_cnt){//插入x_cnt个x
		if(cnt==1) {
			int y=__1st(),d=abs(x-y);
			if(d==0) mp[x]=sta(0,2),ga=0;
			else mp[x]=sta(d,1),mp[y]=sta(d,1),ga=2*sqr(d);
			--x_cnt;++cnt;
			if(x_cnt==0) return;
		}
		auto it=mp.find(x);
		if(it!=mp.end()){
			if(it->second.count==1) ga-=sqr(it->second.min_dist);
			it->second.inc(x_cnt);
		}else{
			it=mp.insert({x,sta(-1,x_cnt)}).first;
			auto dsp=__dist(it);
			int dl=dsp.first[0],dr=dsp.first[1],d=dsp.first[2];
			if(x_cnt>1) d=0;
			it->second.min_dist=d;
			auto pl=dsp.second[0],pr=dsp.second[1];
			int l,r;
			if(dl!=-1 && dl>x-(l=pl->first)){
				ga+=sqr(x-l)-sqr(dl);
				pl->second.min_dist=x-l;
			}
			if(dr!=-1 && dr>(r=pr->first)-x){
				ga+=sqr(r-x)-sqr(dr);
				pr->second.min_dist=r-x;
			}
			ga+=sqr(d);
		}
		cnt+=x_cnt;
	}
	void insert(statistics &st){//暴力合并子树
		for(auto p:st.mp)insert(p.first,p.second.count);
	}
	ll get_ga(){return ga;}
};
 
struct node{
	int fa,val;ll ga;
	vector<int> son;
};

class tree{
	int n;
	vector<node> a;
public:
	tree(int _n):n(_n),a(_n+1){}
	void read(){
		int f;
		for(int i=2;i<=n;++i){
			cin>>f;a[i].fa=f;
			a[f].son.push_back(i);
		}
		for(int i=1;i<=n;++i)cin>>a[i].val;
	}
	int sz(int u){return a[u].son.size()+1;}
	int v(int u){return a[u].val;}
	ll operator[](int u){return a[u].ga;}
	statistics solve(int u){
		statistics st(v(u));
		if(sz(u)==1) {
			a[u].ga=0;
			return st;
		}
		for(auto v:a[u].son){
			auto ret=solve(v);
			st.insert(ret);
		}
		a[u].ga=st.get_ga();
		return st;
	}
};

int main(){
	ios::sync_with_stdio(false);
	int n;
	cin>>n;
	tree tr(n);
	tr.read();
	tr.solve(1);
	for(int i=1;i<=n;++i) cout<<tr[i]<<endl;
	return 0;
}

完整解： 上一个方法慢就慢在两个子树合并的时间复杂度为 O ( n ) O(n) O(n)，如果我们能够采取某种方法 O ( 1 ) O(1) O(1)或者 O ( log ⁡ n ) O(\log n) O(logn)合并子树，那么问题就解决了。

如果你熟练的掌握树链剖分（这里特指轻重链剖分），那么你应该已经想到了解决方案：

总是以重儿子的map为主，然后将轻儿子的map合并到重儿子的map上。

证明： 利用轻重链剖分的性质，一个点到根路径上不超过 log ⁡ n \log n logn条轻边，也就是说，一个点最多会被暴力合并 log ⁡ n \log n logn次。

这种方法被称为树上启发式合并。时间复杂度 O ( n log ⁡ 2 n ) O(n \log^2 n) O(nlog2n)。

事实上，相比40分的代码，以下代码没有很大的改动，仅仅增加了dfs1函数用于寻找重儿子，并对solve递归函数进行了简要修改：

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

typedef long long ll;
ll sqr(int x){return (ll)x*x;}
const int MAXN=3e5+10;

struct sta{
	int min_dist,count;
	sta():min_dist(-1),count(1){}
	sta(int md,int cnt):min_dist(md),count(cnt){}
	void inc(int c=1){
		count+=c;
		if(count>=2) min_dist=0;
	}
};

typedef map<int,sta> dict;
typedef dict::iterator dictit;

class statistics{//个数统计器 
	int cnt;ll ga;
	dict mp;
	int __1st() {return mp.begin()->first;}
	pair<vector<int>,vector<dictit> > __dist(dictit it) {
		vector<int> ret;vector<dictit> retp(3,mp.end());
		int x=it->first,d=INT_MAX;
		if(it==mp.begin()){
			ret.push_back(-1);
		}else{
			auto itl=it;--itl;
			if(x-itl->first<d){
				d=x-itl->first;
				retp[2]=itl;
			}
			ret.push_back(itl->second.min_dist);
			retp[0]=itl;
		}
		auto end=mp.end();--end;
		if(it==end){
			ret.push_back(-1);
		}else{
			auto itr=it;++itr;
			if(itr->first-x<d){
				d=itr->first-x;
				retp[2]=itr;
			}
			ret.push_back(itr->second.min_dist);
			retp[1]=itr;
		}
		ret.push_back(d);
		return {ret,retp};//{左侧数的最小距离，右侧数的最小距离，该数的最小距离},{左侧数的迭代器，右侧数的迭代器，最小距离对应数的迭代器}
	}
public:
	statistics(int x):cnt(1),ga(0){mp[x]=sta(-1,1);}
	void insert(int x,int x_cnt=1){
		if(cnt==1) {
			int y=__1st(),d=abs(x-y);
			if(d==0) mp[x]=sta(0,2),ga=0;
			else mp[x]=sta(d,1),mp[y]=sta(d,1),ga=2*sqr(d);
			--x_cnt;++cnt;
			if(x_cnt==0) return;
		}
		auto it=mp.find(x);
		if(it!=mp.end()){
			if(it->second.count==1) ga-=sqr(it->second.min_dist);
			it->second.inc(x_cnt);
		}else{
			it=mp.insert({x,sta(-1,x_cnt)}).first;
			auto dsp=__dist(it);
			int dl=dsp.first[0],dr=dsp.first[1],d=dsp.first[2];
			if(x_cnt>1) d=0;
			it->second.min_dist=d;
			auto pl=dsp.second[0],pr=dsp.second[1];
			int l,r;
			if(dl!=-1 && dl>x-(l=pl->first)){
				ga+=sqr(x-l)-sqr(dl);
				pl->second.min_dist=x-l;
			}
			if(dr!=-1 && dr>(r=pr->first)-x){
				ga+=sqr(r-x)-sqr(dr);
				pr->second.min_dist=r-x;
			}
			ga+=sqr(d);
		}
		cnt+=x_cnt;
	}
	void insert(statistics &st){
		for(auto p:st.mp)insert(p.first,p.second.count);
	}
	ll get_ga(){return ga;}
};
 
struct node{
	int fa,val;ll ga;
	vector<int> son;
	int sz,hson;
};

class tree{
	int n;
	vector<node> a;
	void dfs1(int u,int f) { //寻找重儿子 
	    a[u].sz=1;
	    for(auto v:a[u].son) {
	        if(v==f)continue;
	        dfs1(v,u);
	        a[u].sz+=a[v].sz;
	        if(a[a[u].hson].sz<a[v].sz) a[u].hson=v;
	    }
	}
public:
	tree(int _n):n(_n),a(_n+1){}
	void read(){
		int f;
		for(int i=2;i<=n;++i){
			cin>>f;a[i].fa=f;
			a[f].son.push_back(i);
		}
		for(int i=1;i<=n;++i)cin>>a[i].val;
		dfs1(1,0);
	}
	int sz(int u){return a[u].son.size()+1;}
	int hson(int u){return a[u].hson;}
	int v(int u){return a[u].val;}
	ll operator[](int u){return a[u].ga;}
	statistics solve(int u){
		if(sz(u)==1) {
			a[u].ga=0;
			return statistics(v(u));
		}
		statistics st=solve(hson(u));
		for(auto v:a[u].son){
			if(v==hson(u))continue; 
			auto ret=solve(v);
			st.insert(ret);
		}
		st.insert(v(u));
		a[u].ga=st.get_ga();
		return st;
	}
};

int main(){
	ios::sync_with_stdio(false);
	int n;
	cin>>n;
	tree tr(n);
	tr.read();
	tr.solve(1);
	for(int i=1;i<=n;++i) cout<<tr[i]<<endl;
	return 0;
}

5. 星际网络

（日后更新）

fmy_xfk
关注
  • 5
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
csp.js：:television:适用于原始JavaScript的CSP
01-28
CSP.js 该库提供适用于原始JavaScript的CSP原语。 如果您以前使用过Clojure的 ，则选择CSP.js很容易。 非常感谢。 该库的大部分内容是core.async的Clojure代码到JavaScript的直接翻译。 例 以下示例可以在找到。 ...
ACM/NOI/CSP比赛指南：如何利用网络资源提高自己的创新创业能力
01-04
# ACM/NOI/CSP比赛指南：如何利用网络资源提高自己的算法竞赛能力 # ACM/NOI/CSP比赛指南：如何利用网络资源提高自己的算法竞赛能力 ACM/NOI/CSP是三项面向全国高校和中学生的算法竞赛，旨在培养学生的算法设计和...
CCF-CSP认证考试 202212-5 星际网络 52/68分题解
最新发布
Pujx的博客
03-30 1189
52分：线段树建图 —— 68分：线段树建图、高精度
CSP202212-5---＞星际网络（20分代码）
weixin_51954774的博客
03-10 1208
CSP
CCF CSP认证最新2022-12题解c++(全网首发)
m0_54245948的博客
03-12 2003
首发最新ccf题解
CSP计算机软件能力认证 2022年12月 题解
qq_18626053的博客
03-14 513
树上启发式合并，用 multiset 维护当前的值的集合，用 val 记录当前的答案，每进来一个值现在 multiset 里面找前驱和后继，因为新进来的值可能对这俩造成影响，然后再把离自己近的加到答案里面。先把树建出来，dfs下去的时候记一下最早的时间，回溯的时候记录最晚时间。看起来像线段树优化建图，还没写，写了再更新。
ccf csp 202212星际网络 4分（未优化）
weixin_44124824的博客
02-26 917
星际网络求解的抛砖引玉
【CSP】试题编号 202212-2 试题名称： 训练计划 AC
Dershy_的博客
02-19 2099
问题背景西西艾弗岛荒野求生大赛还有天开幕！问题描述为了在大赛中取得好成绩，顿顿准备在天时间内完成“短跑”、“高中物理”以及“核裂变技术”等总共项科目的加强训练。其中第项（）科目编号为，也可简称为科目。已知科目耗时天，即如果从第天开始训练科目，那么第天就是该项训练的最后一天。大部分科目的训练可以同时进行，即顿顿在同一天内可以同时进行多项科目的训练，但部分科目之间也存在着依赖关系。如果科目依赖科目，那么只能在后者训练结束后，科目。
inline-csp-hash:插件为CSP的内联脚本和样式生成哈希
04-29
内联csp哈希 用于为CSP的内联脚本和样式生成哈希的插件。 该插件受约束，并且操作方式大致相同。安装npm install inline-csp-hash --save用法const gulp = require ( 'gulp' ) ;const hashstream = require ( '...
CCF考试历年真题代码（第一题）
12-04
- 文件名中的"CCF练习"暗示了这是针对CCF CSP考试的训练资料，考生可以通过这些代码学习如何用Java解决实际问题。 2. **算法设计** - CSP考试的核心是算法，包括排序、搜索、图论、动态规划等经典算法。每个题目...
go-csp-collector:用Golang编写的CSP收集器
05-19
跑步$ go build csp_collector.go$ ./csp_collector为Docker构建为此，您要么需要在CGO_ENABLED=0容器中进行构建，要么使用CGO_ENABLED=0标志使该构建与CGO_ENABLED=0容器中的alpine linux兼容。 $ CGO_ENABLED=0 go...
ccf- csp 202212-3 JPEG 解码
qssssss79的博客
03-16 177
ccf- csp 202212-3 JPEG 解码
CCF-CSP 202303 星际网络Ⅱ 90=＞100题解
vermouth_1412的博客
04-07 1452
为了防止[1,2],[4,5]离散后变为[1,2],[3,4]而导致后续地址段[2,4]不可分，我们需要在一对一映射基础上进行额外操作。：线段树操作前不能偷懒的利用全局变量为0的特点，建树操作以赋初始bh值为负无穷，bl为正无穷是有必要的。级别区域的地址映射为O(q)级别，而后排序，去重。将操作一、二、三中分布于。
CCF-CSP202303D题星际网络II【100分】（结构清晰）
m0_50521245的博客
05-25 750
CCF-CSP202303D题星际网络II【100分】（结构清晰）
CCF- CSP 202012-5星际旅行 80分骗分题解
只须一笑不须愁X的博客
09-16 922
【代码】CCF- CSP 202012-5星际旅行 80分骗分题解。
CSP 202012-5 星际旅行(60分)
旺崽的博客
03-16 2647
题目链接 一个优秀的 OI 选手一定要学会如何在实力范围内骗最大的分，我们每一题可以都不求满分，但是要尽可能拿到最多的分~ 就拿这题来说，个人觉得比那道模拟好拿分，首先看第一个 20 分，看数据范围很明显就是送的，就是暴力，这个 20 分一定要拿到手~ 接着看第二个 20 分，只有区间更新和区间求助，非常明细的线段树，送分~ 接着看第三个 20 分，这里就比较难了，我们发现此时的线段树要两种操作，一个区间加值，一个区间求值，此时我们需要先乘再加，添加一个乘的懒惰标记，具体模改看我代码~ 到这里你就已经有了
星际网络Ⅱ做题笔记
m0_66822426的博客
08-05 130
星际网络Ⅱ题目详细注释和做题笔记
CSP202012-5 星际旅行 满分详解
qq_43381135的博客
03-12 3343
CSP202012-5 星际旅行 满分详解题目结果算法分析详细代码讲解完整满分代码 题目 题目可以在CSP官网中查看到哟！ 结果 算法分析 详细代码讲解 完整满分代码
CSP2020-12-5星际旅行(未优化线段树60，优化后100，暴力可拿80！)
all23333333的博客
04-15 727
题目描述： 乔帝要规划一次星际旅行，星际空间可以视为一个 3 维坐标系，乔帝有 n(n≤1,000,000,000) 个动力装置排成一行(下标从 1 到 n )。 第 i 个动力装置可以让他的飞船 3 个维度的坐标分别增加 xi,yi,zi 。一开始这些动力装置的所有参数都是 0 。 在规划过程中，乔帝可能会对动力装置进行调整，也可能会对一些动力装置的动力进行评估。 具体来说，乔帝会进行 m(m≤40000) 次操作，每次操作可能是以下四种操作之一： 动力增加：指定一个区间 [L,R] 和三个参数 a,b,
csp202212-2c++训练计划
07-27
对于csp202212-2题目中的c++训练计划，我们需要知道c++训练的编号以及训练的时间。根据题目描述，我们可以得知c++训练的编号为2。然而，题目中没有提供c++训练的具体时间。因此，我们无法确定c++训练的时间。 综上...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值