CCF 区块链 201912-4 5218ms

最新推荐文章于 2021-11-10 09:30:00 发布
最新推荐文章于 2021-11-10 09:30:00 发布
阅读量2.2k 收藏 4
点赞数 1
分类专栏： 2019年7月~9月CSP竞赛复习准备 文章标签： 201912-4 ccf 区块链 201912 csp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/best335/article/details/104097464
版权

文章目录

点击前往试题目录：https://blog.csdn.net/best335/article/details/99550556

题目描述

在这里插入图片描述

解题思路

题意简单清晰：

  • 总共不超过500个节点，编号1~n。
  • 每个节点各自维护一条主链，初始时每个链的长度为1，值为0，最大长度为500。
  • 节点间共有m条相互可达的无向路径。
  • 更新策略：
    • 主动更新：
      • 输入a b c
    • 被动更新：
      • 相邻节点更新后经过传输延时t后
      • 相邻接点主链长度更长 或者 两条链长度相同且相邻节点尾块块号更小
  • 有更新延时t，不超过1000。
  • 每次更新可以看做是做一次关于当前时间b+传输延时t的更新。
  • 有两种操作：
    • 更新主链：
      • 该行格式为：a b c
      • 格式解释：更新a节点在b时刻向其主链添加块号c
      • 注意：|c|<109
    • 查询主链：该行格式为：a b
      • 格式解释：查询在b时刻a节点的主链
      • 输出格式：a节点主链长度[空格]顺序输出主链块号，每个块号中间用空格相隔

仔细审题之后，发现这道题涉及一点图的BFS以及SPFA。

定义：
转折点：任意相邻两行b不同时的第二行的b为转折时间，简称转折点。

决策：

  • 使用vector G[501]建立无向图

  • 使用vector Links[501]维护转折点的实时主链

  • 使用unordered_map<int, unordered_map<int,vector > > F
    维护临时主链<时间，<节点，节点更新时的临时主链> >

  • unordered_map<int, vector > tmpSearch
    维护转折点前的查询队列<查询时间,查询节点队列>

  • unordered_map<int, unordered_map<int, int> > tmpUpdate
    维护转折点前的更新队列<更新时间,<更新节点，更新块号> >

  • 每次在转折点的时刻或所有输入结束时做如下操作：

    • 按队列时间顺序接收和更新所有转折点之前的主链
    • 处理转折点之前的查询
    • 处理转折点之前的更新

博主精力有限，暂不深究未满分原因，以上解题思路希望对你们有帮助。
博主精力有限，暂不深究未满分原因，以上解题思路希望对你们有帮助。
博主精力有限，暂不深究未满分原因，以上解题思路希望对你们有帮助。

以下代码需要你静下心来阅读

70分代码

备注：代码底部有测试数据

#include<iostream>
#include<vector>
#include<map>
#include<set>
#include<unordered_map>
#include<unordered_set>
#include<string>
using namespace std;

vector<int> G[501];//图
vector<int> Links[501];//主链
set<int> Q;//更新时间点队列索引
set<int>::iterator itQ;
unordered_map<int, unordered_map<int,vector<int> > > F;//更新时间点队列
unordered_map<int, unordered_map<int,vector<int> > >::iterator itF;
int n,m,t,k,u,v,a,b,c;//题意参数

set<int> TS,TU;//TS：tempsearch查询队列索引  TU：tempUpdate更新队列索引
set<int>::iterator itTS,itTU;
unordered_map<int, vector<int> > tmpSearch;//查询队列
unordered_map<int, vector<int> >::iterator itTmpS;
unordered_map<int, unordered_map<int, int> > tmpUpdate;//更新队列
unordered_map<int, unordered_map<int, int> > ::iterator itTmpU;

void enque(const int& time,const int& point){//标记time时刻point节点将要更新
	unordered_map<int, unordered_map<int,vector<int> > >::iterator it = F.find(time);
	if(it == F.end()){
		Q.insert(time);
		unordered_map<int,vector<int> > M;
		M.insert(pair<int,vector<int> >(point,vector<int>(Links[point])));
		F.insert(pair<int,unordered_map<int,vector<int> > >(time,M));
	}
	else{
		unordered_map<int, vector<int> >::iterator itM = it->second.find(point);
		if (itM == it->second.end()) {
			it->second.insert(pair<int, vector<int> >(point, vector<int>(Links[point])));
		}
		else {
			const vector<int>& vM = itM->second;
			int n1 = Links[point].size(), n2 = vM.size();
			if (n1 > n2 || n1 == n2&&Links[point].back() < vM.back()) {
				itM->second = vector<int>(Links[point]);
			}
		}
	}
}

void receiveChain() {//接收查询或更新前的主链  这个函数有点绕
	int timeQ = Q.empty() ? ::b : 0, timeT, flagQ=0, b = TS.empty()? ::b : *TS.begin();
	do {
		while(!TU.empty()&& (timeT = *(itTU = TU.begin())) < timeQ){//更新timeQ时间点前的主链信息 注意timeQ的取值 为了复用外围嵌套了一个do while循环
			const unordered_map<int,int>& M = tmpUpdate.find(timeT)->second;
			for (unordered_map<int,int>::const_iterator itM = M.begin(); itM != M.end(); ++itM){
				Links[itM->first].emplace_back(itM->second);
				enque(timeT + t, itM->first);
			}
			TU.erase(itTU);
			tmpUpdate.erase(timeT);
		}
		if (flagQ == 1) {//如果不是第一次循环 更新邻接点主链信息
			const unordered_map<int,vector<int> >& M = F.find(timeQ)->second;
			for (unordered_map<int,vector<int> >::const_iterator itM = M.begin(); itM != M.end(); ++itM) {
				const int& v = itM->first;
				const vector<int>& link = itM->second;
				for (int i = 0, ni = G[v].size(), n1, n2; i<ni; ++i) {
					n1 = link.size(), n2 = Links[G[v][i]].size();
					if (n1<n2 || n1 == n2&&link.back() >= Links[G[v][i]].back()) continue;

					Links[G[v][i]] = link;
					enque(t + timeQ, G[v][i]);
				}
			}
			F.erase(timeQ);
			Q.erase(itQ);
			continue;
		}
		flagQ = 1;
	} while (!Q.empty() && (timeQ = *(itQ = Q.begin())) <= b);
}

void outputChain() {//输出所有转折时间点之前待查询的节点
	for (itTS = TS.begin(); itTS != TS.end();++itTS) {
		itTmpS = tmpSearch.find(*itTS);
		const vector<int>& V = itTmpS->second;
		itTmpU = tmpUpdate.find(itTmpS->first);
		for (int i = 0, ni = V.size(), link_length, link_value, link_flag; i<ni; ++i) {
			link_length = Links[V[i]].size();
			link_flag = 0;
			if (itTmpU != tmpUpdate.end()) {
				const unordered_map<int, int>& M = itTmpU->second;
				unordered_map<int, int>::const_iterator itM = M.find(V[i]);
				if (itM != M.end()) {
					++link_length;
					link_flag = 1;
					link_value = itM->second;
				}
			}
			cout << link_length;
			for (int j = 0, nj = Links[V[i]].size(); j<nj; ++j) {
				cout << ' ' << Links[V[i]][j];
			}
			if (link_flag == 1) {
				cout << ' ' << link_value;
			}
			cout << endl;
		}
	}
	tmpSearch.clear();
	TS.clear();
}

void updateChain() {//更新主链
	for(itTmpU=tmpUpdate.begin();itTmpU!=tmpUpdate.end();++itTmpU){
		const unordered_map<int,int>& M = itTmpU->second;
		const int & timeU = itTmpU->first;
		for (unordered_map<int, int>::const_iterator itM = M.begin(); itM != M.end(); ++itM) {
			Links[itM->first].emplace_back(itM->second);
			enque(timeU + t, itM->first);
		}
	}
	tmpUpdate.clear();
	TU.clear();
}

void solve(){
	receiveChain();
	outputChain();
	updateChain();
}

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cin>>n>>m;
	for(int i=0;i<m;++i){
		cin>>u>>v;
		G[u].emplace_back(v);
		G[v].emplace_back(u);
	}
	for (int i = n; i > 0; --i) {
		Links[i].emplace_back(0);
	}

	cin>>t>>k;
	string s;
	for(int i=0,j,nj,lastTaskId=1,xk=k-1,type;i<k;++i){
		cin>>a>>b,type=-1;
		getline(cin,s);
		//以下直到空行区域内判断该输入行有几个数字 type==-1?两个数字：三个数字
		j=0,nj = s.size();
		while(j<nj&&s[j]==' ') ++j;
		bool isNegative = j<nj&&s[j]=='-'&&++j>0;//判断负数 如果是负数自加索引指针j
		if(j<nj&&isdigit(s[j])){
			c=0;
			type=0;
			while(j<nj&&isdigit(s[j])){
				c=c*10+(s[j]-'0');
				++j;
			}
			if(isNegative) c=-c;
		}

		if(b!=lastTaskId){//转折点
			solve();
		}
		
		if(type==-1){//两个数 放入查询队列
			if ((itTmpS = tmpSearch.find(b)) == tmpSearch.end()) {
				vector<int> v(1,a);
				tmpSearch.insert(pair<int, vector<int> >(b,v));
				TS.insert(b);
			}
			else {
				itTmpS->second.emplace_back(a);
			}
		}
		else{//三个数  放入更新队列
			if((itTmpU=tmpUpdate.find(b))==tmpUpdate.end()){
				unordered_map<int,int> M;
				M.insert(pair<int,int>(a,c));
				tmpUpdate.insert(pair<int,unordered_map<int,int> >(b,M));
				TU.insert(b);
			}
			else{
				itTmpU->second.insert(pair<int,int>(a,c));
			}
		}
		
		if(i==xk&&!tmpSearch.empty()){//转折点
			solve();
		}
		lastTaskId=b;
	}
	return 0;
}
/*
5 10
1 2
1 3
1 4
1 5
2 3
2 4
2 5
3 4
3 5
4 5
1 27
1 1 1
2 1 2
3 1 3
4 1 4
5 1 5
1 1
2 1
3 1
4 1
5 1
1 2
2 2
3 2
4 2
5 2
1 10 10
2 11 9
1 11
2 11
3 11
4 11
5 11
1 12
2 12
3 12
4 12
5 12


15 13
1 2
2 3
3 4
4 5
1 6
6 7
7 8
8 9
1 10
10 11
11 12
12 13
14 15
6 28
1 1 1
1 2 2
1 6
2 7
13 7
9 7
5 7
3 14
8 14
5 14
11 14
9 25
5 25
13 25
9 29 3
5 29 4
13 29 5
1 53
2 59 6
2 59
1 1000
3 1000
8 1000
9 1000
10 1000
13 1000
14 1000
15 1000
*/

时间压力测试代码

注意在enque函数加入如下代码限制主链长度不超过500
输出时记得输出到文件，输出到控制台时耗时高很多。
测试时时耗大概：5000ms

#include<iostream>
#include<vector>
#include<map>
#include<set>
#include<unordered_map>
#include<unordered_set>
#include<string>

#define DEBUG 1
#ifdef DEBUG
	#include<fstream>
	#include<ctime>
	std::ofstream LOG("log.txt");
#endif
using namespace std;

vector<int> G[501];
vector<int> Links[501];
set<int> Q;
set<int>::iterator itQ;
unordered_map<int, unordered_map<int,vector<int> > > F;
unordered_map<int, unordered_map<int,vector<int> > >::iterator itF;
int n,m,t,k,u,v,a,b,c;

set<int> TS,TU;
set<int>::iterator itTS,itTU;
unordered_map<int, vector<int> > tmpSearch;
unordered_map<int, vector<int> >::iterator itTmpS;
unordered_map<int, unordered_map<int, int> > tmpUpdate;
unordered_map<int, unordered_map<int, int> > ::iterator itTmpU;

void enque(const int& time,const int& point){
	#ifdef DEBUG
		if(Links[point].size()>500) return; 
	#endif
	unordered_map<int, unordered_map<int,vector<int> > >::iterator it = F.find(time);
	if(it == F.end()){
		Q.insert(time);
		unordered_map<int,vector<int> > M;
		M.insert(pair<int,vector<int> >(point,vector<int>(Links[point])));
		F.insert(pair<int,unordered_map<int,vector<int> > >(time,M));
	}
	else{
		unordered_map<int, vector<int> >::iterator itM = it->second.find(point);
		if (itM == it->second.end()) {
			it->second.insert(pair<int, vector<int> >(point, vector<int>(Links[point])));
		}
		else {
			const vector<int>& vM = itM->second;
			int n1 = Links[point].size(), n2 = vM.size();
			if (n1 > n2 || n1 == n2&&Links[point].back() < vM.back()) {
				itM->second = vector<int>(Links[point]);
			}
		}
	}
}

void receiveChain() {
	int timeQ = Q.empty() ? ::b : 0, timeT, flagQ=0, b = TS.empty()? ::b : *TS.begin();
	do {
		while(!TU.empty()&& (timeT = *(itTU = TU.begin())) < timeQ){
			const unordered_map<int,int>& M = tmpUpdate.find(timeT)->second;
			for (unordered_map<int,int>::const_iterator itM = M.begin(); itM != M.end(); ++itM){
				Links[itM->first].emplace_back(itM->second);
				enque(timeT + t, itM->first);
			}
			TU.erase(itTU);
			tmpUpdate.erase(timeT);
		}
		if (flagQ == 1) {
			const unordered_map<int,vector<int> >& M = F.find(timeQ)->second;
			for (unordered_map<int,vector<int> >::const_iterator itM = M.begin(); itM != M.end(); ++itM) {
				const int& v = itM->first;
				const vector<int>& link = itM->second;
				for (int i = 0, ni = G[v].size(), n1, n2; i<ni; ++i) {
					n1 = link.size(), n2 = Links[G[v][i]].size();
					if (n1<n2 || n1 == n2&&link.back() >= Links[G[v][i]].back()) continue;

					Links[G[v][i]] = link;
					enque(t + timeQ, G[v][i]);
				}
			}
			F.erase(timeQ);
			Q.erase(itQ);
			continue;
		}
		flagQ = 1;
	} while (!Q.empty() && (timeQ = *(itQ = Q.begin())) <= b);
}

void outputChain() {
	for (itTS = TS.begin(); itTS != TS.end();++itTS) {
		itTmpS = tmpSearch.find(*itTS);
		const vector<int>& V = itTmpS->second;
		itTmpU = tmpUpdate.find(itTmpS->first);
		for (int i = 0, ni = V.size(), link_length, link_value, link_flag; i<ni; ++i) {
			link_length = Links[V[i]].size();
			link_flag = 0;
			if (itTmpU != tmpUpdate.end()) {
				const unordered_map<int, int>& M = itTmpU->second;
				unordered_map<int, int>::const_iterator itM = M.find(V[i]);
				if (itM != M.end()) {
					++link_length;
					link_flag = 1;
					link_value = itM->second;
				}
			}
			#ifdef DEBUG
				LOG << link_length;
			#endif
			for (int j = 0, nj = Links[V[i]].size(); j<nj; ++j) {
			#ifdef DEBUG
				LOG << ' ' << Links[V[i]][j];
			#endif
			}
			if (link_flag == 1) {
			#ifdef DEBUG
				LOG << ' ' << link_value;
			#endif
			}
			#ifdef DEBUG
				LOG << endl;
			#endif
		}
	}
	tmpSearch.clear();
	TS.clear();
}

void updateChain() {
	for(itTmpU=tmpUpdate.begin();itTmpU!=tmpUpdate.end();++itTmpU){
		const unordered_map<int,int>& M = itTmpU->second;
		const int & timeU = itTmpU->first;
		for (unordered_map<int, int>::const_iterator itM = M.begin(); itM != M.end(); ++itM) {
			Links[itM->first].emplace_back(itM->second);
			enque(timeU + t, itM->first);
		}
	}
	tmpUpdate.clear();
	TU.clear();
}

void solve(){
	receiveChain();
	outputChain();
	updateChain();
}

int main(){
	#ifdef DEBUG
		ifstream cin("input.txt");
		clock_t c1 = clock();
	#endif
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cin>>n>>m;
	for(int i=0;i<m;++i){
		cin>>u>>v;
		G[u].emplace_back(v);
		G[v].emplace_back(u);
	}
	for (int i = n; i > 0; --i) {
		Links[i].emplace_back(0);
	}

	cin>>t>>k;
	string s;
	for(int i=0,j,nj,lastTaskId=1,xk=k-1;i<k;++i){
		cin>>a>>b,c=-1;
		getline(cin,s);
		j=0,nj = s.size();
		while(j<nj&&s[j]==' ') ++j;
		bool isNegative = j<nj&&s[j]=='-'&&++j>0;
		if(j<nj&&isdigit(s[j])){
			c=0;
			while(j<nj&&isdigit(s[j])){
				c=c*10+(s[j]-'0');
				++j;
			}
			if(isNegative) c=-c;
		}

		if(b!=lastTaskId){
			solve();
		}
		
		if(c==-1){
			if ((itTmpS = tmpSearch.find(b)) == tmpSearch.end()) {
				vector<int> v(1,a);
				tmpSearch.insert(pair<int, vector<int> >(b,v));
				TS.insert(b);
			}
			else {
				itTmpS->second.emplace_back(a);
			}
		}
		else{
			if((itTmpU=tmpUpdate.find(b))==tmpUpdate.end()){
				unordered_map<int,int> M;
				M.insert(pair<int,int>(a,c));
				tmpUpdate.insert(pair<int,unordered_map<int,int> >(b,M));
				TU.insert(b);
			}
			else{
				itTmpU->second.insert(pair<int,int>(a,c));
			}
		}
		
		if(i==xk&&!tmpSearch.empty()){
			solve();
		}
		lastTaskId=b;
	}

	#ifdef DEBUG
		clock_t c2 = clock();
		cout << endl << c2 - c1 << "ms" << endl;
	#endif
	return 0;
}

#include<iostream>
#include<cstdlib>
#include<fstream> 
#include<set>
using namespace std;

int main(){
	int n = 500,m = 10000,t=rand()%1000+1,k=30000;
	ofstream fout("input.txt");
	set<pair<int,int> > S;
	
	fout<<n<<" "<<m<<endl;
	while(S.size()<m){
		int u = rand()%500 + 1,v = rand()%500 +1;
		pair<int,int> p;
		if(u<v){
			p = pair<int,int>(u,v);
		}
		else{
			p = pair<int,int>(v,u);
		}
		if(S.find(p)==S.end()){
			fout<<p.first<<" "<<p.second<<endl;
				S.insert(p);
		}
	}
	
	fout<<t<<" "<<k<<endl;
	for(int i=0,a,b = 1,c;i<k;++i){
		a = rand()%500 + 1;
		if((rand()%100)>60){
			if((rand()%100)>80){
				b = b +(rand()%t) + (t*rand())%3;
			}
			else{
				b = b +rand()%t;
			}
		}
		c = 1*rand()*rand()*rand();
		if((rand()%100)>30){
			fout<<a<<" "<<b<<endl;
		}
		else{
			fout<<a<<" "<<b<<" "<<c<<endl;
		}
	}
	
	return 0;
}
best335
关注
专栏目录
CCF计算机软件能力认证试题练习：201912-4 区块链（未解决）
WINGREZ‘S BLOG
12-15 4350
区块链 来源：CCF 标签： 参考资料： 相似题目： 题目 区块链涉及密码学、哈希算法、拜占庭问题、共识算法、故障模型、网络模型等诸多知识，也在金融等领域有广泛的应用。本题中，我们需要实现一个简单的区块链系统。 在一个分布式网络中，有n个节点通过m条边相连，节点编号从1至n。每个节点初始化都有一个相同的“创世块”，链长都为1，每个节点在整个过程中都需要维护一条主链，任何操作都只在主链上进行。...
[系统安全] 二十一.PE数字签名之(中)Signcode、PEView、010Editor、Asn1View工具用法
杨秀璋的专栏
02-09 7308
作者前文介绍了什么是数字签名，并采用Signtool工具对EXE文件进行签名，后续深入分析数字签名的格式及PE病毒内容。这篇文章将详细解析数字签名，采用Signtool工具对EXE文件进行签名，接着利用Asn1View、PEVie、010Editor等工具进行数据提取和分析，这是全网非常新的一篇文章，希望对您有所帮助。 这些基础性知识不仅和系统安全相关，同样与我们身边常用的软件、文档、操作系统紧密联系，希望这些知识对您有所帮助，更希望大家提高安全意识，安全保障任重道远。本文参考了参考文献中的文章，并结合自己
【CCF 201912-4】区块链（队列：80分）
Salmon_lee的博客
02-09 1331
写在前面 最近几次的CFF-CSP考试，我发现一个趋势。CSP的第3、4题会与计算机的专业知识密切相关。 例如：化学方程式 – 编译原理，RAID5 – 操作系统。而本题涉及到的是分布式系统的应用（区块链）。 题目大意 给出一个网络，每个结点中都有一个主链。 当一个结点的主链更新时，将会向它的邻居发送它的主链；邻居会将这个主链和邻居自己的链进行比较，决定是否接收这个链（即替换自己的链）。 更新有...
CCF 201912-4 区块链（STL模拟）
tomjobs的博客
04-02 445
好难写的一道题，一开始写是每次记录下每个时间的被传输链和新增块，然后每更新一次bfs全图，但是写不对。。。 下面的代码是参考 https://blog.csdn.net/richenyunqi/article/details/104155384 #include <cstdio> #include <cstring> #include <algorithm> ...
201912-4 区块链
hei_hei_hei_的博客
03-08 438
试题编号： 201912-4 试题名称： 区块链 时间限制： 10.0s 内存限制： 512.0MB 思路from网上：按照时间顺序依次处理每个节点接收链和产生块。详见代码注释 小技巧：每个节点的接收链在传递的时候可以更新，因此接收链实际上可以是一条。 #include<iostream> #include<map> #include<unordered_map...
CCF认证201912-4. 区块链
WJS_Romantic的博客
03-15 358
题目描述 算法设计 大模拟题，主要是要用好STL。我们使用vector<vector<int>> graph存储节点和边，用vector<vector<int>> ans存储每个结点当前的主链。关键是如何存储表示接收链和产生块的操作。我们使用map<int, unordered_map<int, array<vector&l...
区块链不同机器的节点相互连接
DDFFR的博客
07-06 5967
1节点所在的机器，相互之间可以互联互通 2它们有相同的创世纪文件 3 有相同的networkid一 第一个节点创建root@i-67u87x1c:/home/ubuntu# mkdir private-geth root@i-67u87x1c:/home/ubuntu# cd private-geth/ root@i-67u87x1c:/home/ubuntu/private-geth# vim
[系统安全] 二十.PE数字签名之(上)什么是数字签名及Signtool签名工具详解
杨秀璋的专栏
02-07 7352
作者前文介绍了宏病毒相关知识，它仍然活跃于各个APT攻击样本中，具体内容包括宏病毒基础原理、防御措施、自发邮件及APT28样本分析。本文将详细介绍什么是数字签名，并采用Signtool工具对EXE文件进行签名，后续深入分析数字签名的格式及PE病毒内容。这些基础性知识不仅和系统安全相关，同样与我们身边常用的软件、文档、操作系统紧密联系，希望这些知识对您有所帮助，更希望大家提高安全意识，安全保障任重道远。本文参考了参考文献中的文章，并结合自己的经验和实践进行撰写，也推荐大家阅读参考文献。
219-6-3Google浏览器书签备份
qq_43046057的博客
06-03 3634
WAF 创建时间 2019-03-11 12:45:27 最后修改 2019-04-03 14:02:50>> 书签名称 链接 添加时间 WEB漏洞测试（二）——HTML注入 & XSS攻击 - CSDN博客 http://www.secsky.cn/216.html 2018-05-15 10:45:24 ModSecurity介绍 - CSDN博客...
【论文推荐】 2021-11-10 云间周报 | 十月初六 | 星期三 | 今日宜运动
热门推荐
tanya_dre的博客
11-10 1万+
01 自然语言处理： “NLP-Fast: A Fast, Scalable, and Flexible System to Accelerate Large-Scale Heterogeneous NLP Models” 译：NLP-Fast: 一个用于加速大规模异构NLP模型的快速、可扩展、灵活的系统 简介：现有的NLP模型中不能提供足够的可扩展性和灵活性，因为它们既没有识别也没有优化最近的NLP模型中出现的广泛的性能关键操作，而只是专注于优化特定操作。因此，本文提出了NLP-Fast，一个以.
CCF-CSP 201912-4区块链
01-07
CCF-CSP 201912-4区块链 看了大佬博客（https://blog.csdn.net/richenyunqi/article/details/104155384）以后写的，本来想着看完按自己思路写，但是最后写出来差不多，但是我80分，运行超时。 #include using namespace std; map<int>>> operation;//operation[a][b][0/1]表示a时刻需要b节点需要接收的链和块 vector<vector> ans(505,{0}); vectorgraph[50
CCF计算机软件能力认证试题练习：201912-4 区块链
qq_41210304的博客
03-01 724
CCF计算机软件能力认证试题练习：201912-4 区块链（90分） ps:总之还是太菜了，大佬一会就搞好了，本菜鸡搞了4个小时左右。 好在最后搞出来了，90分，运行错误。 这里要注意：同一时间点，同一个节点，会产生多个块。 题目描述这里就不给出来了，官网都有，直接贴代码。 import java.util.*; /** * 区块链90分 */ public class Main{ ...
ccf csp-201912-4-区块链（双端队列bfs+链表）
波点兔的博客
03-12 661
参考博客：点这里 对样例1的过程模拟 初始状态 时刻1，每个节点都产生一个块 时刻2，所有结点接收到邻居发来的主链，更新自己的主链 时刻10，结点1产生新块10 时刻11，所有结点接收到邻居发来的主链，更新自己的主链（时刻11的同时，结点2先接收链，再产生新块9） 时刻12，所有结点接收到邻居发来的主链，更新自己的主链 代码如下 #include<bits/std...
CCF_201912-4试题及答案（Java )
tylz970408的博客
03-22 338
CCF_201912-4（java）题目分析代码 题目 分析 这一题就是考对图的操作，涉及到两个图，一个就是节点之间连接关系的无向图，另一个就是节点后面所跟块的有向图。两个图均可用邻接表进行存储，做起来也不太难，就是对邻接表的比较和更新，对于更新时间和其他信息，我用一个队列来进行存储，但是可能对题目隐含的信息理解不够，我只得了50分，以下代码仅供参考，如果以后有时间会再进行更新，也希望大家能...
CCF 201912-4 区块链--复杂模拟
Slifer the Sky Dragon
02-22 1091
思路： 这道题思想上是BFS广度搜索，信息的传递符合BFS算法，但如果套用BFS算法将不可避免导致各节点存储大量信息而导致空间溢出，所以这道题只能分步传递信息，节点收到信息后先处理（删除无用信息），这样可以拿到满分。 #include<bits/stdc++.h> using namespace std; int n,m,t,k; vector<vector<int&gt...
201912-4 CCF CSP 区块链(80)分 TLE
u011902923的博客
09-09 225
很惭愧，第四题两个 #include<bits/stdc++.h> #pragma GCC optimize(2) #define For(i,m,n) for(register int i=m;i<n;i++) #define rFor(i,m,n) for(register int i=m;i>n;i--) #define r(a) read(a) #define rr(a,b) read(a),read(b) #define rrr(a,b,c) read(a),read(b)
CCF CSP 竞赛试题——区块链（201912-4）
Touchig的博客
01-21 3794
这题有一个大坑：同一节点，同一时间，可能产生多个块。即，存在 ai bi cia_i\ b_i\ c_iai​ bi​ ci​ 和 aj bj cja_j\ b_j\ c_jaj​ bj​ cj​ ，其中 ai=aj,bi=bja_i = a_j, b_i = b_jai​=aj​,bi​=bj​ ，这样的输入存在。（...
CCF CSP攻克之路 —— 2019_12
努力上进的小叶
02-17 423
CCF CSP 2019_121：报数（100）*1.1 题目1.2 代码与解答2： 回收站选址（20/）2.1 题目2.2 代码与解答3： 化学方程式3.1 题目3.2 代码与解答4： 区块链4.1 题目4.2 代码与解答5：魔数5.1 题目5.2 代码与解答 1：报数（100）* 1.1 题目 1.2 代码与解答 #include<bits/stdc++.h> using n...
201912-2 回收站选址
最新发布
09-01
- *2* *3* [CCF_Java_201912-2_回收站选址](https://blog.csdn.net/weixin_43662429/article/details/104051247)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值