CCF CSP 数字点亮人生

最新推荐文章于 2022-05-17 15:05:38 发布
最新推荐文章于 2022-05-17 15:05:38 发布
阅读量346 收藏
点赞数
分类专栏： CCF
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AlenLoveCode/article/details/110943061
版权
CCF CSP 数字点亮人生 更新

2021.4.10 明天就考CSP了，我重新复习了之前的代码思路，我才发现，我这题写的TM是什么鬼，注释都不写，根本看不懂，后面又写了一份，带了些注释，应该会好理解一点
在这里插入图片描述
在这里插入图片描述

第一份 代码短，时间长

#include<bits/stdc++.h>
using namespace std;
enum{NOT,AND,OR,XOR,NAND,NOR
};
int M[3100][3100];
int N,m,k,T;   //实际上m就是k，我懒得改了，不用在意 
struct node{   
	int statu;  //什么门 
	int out;  //每个逻辑电路 输出值  或   输入的 值 
};
node P[3100];//输入部分+逻辑电路部分 
int in[3100];  //记录入度 
int Tra(string s)   
{
	if(s=="NOT") return NOT;
	if(s=="AND")  return AND;
	if(s=="OR") return OR;
	if(s=="XOR") return XOR;
	if(s=="NAND") return NAND;
	if(s=="NOR") return NOR; 
	
}

bool Judge_c()//判环 
{
	int sum=0;
	stack<int> S;
	for(int i=k+1;i<=T;i++)
		if(in[i]==0)
			S.push(i),sum++;
	while(S.size()!=0)
	{
		int v=S.top();
		S.pop();
		for(int i=k+1;i<=T;i++)
			if(M[v][i]==1)
			{
		 	  in[i]--;
			  if(in[i]==0)
			  S.push(i),sum++;
			}
	}
	if(sum==N)
			return false;
	else 
		return true;
}
void init()  //同一电路下，只改变输出，每次更新输出后所用的初始化 
{
	for(int i=1;i<=T;i++)
		P[i].out=-1;
}
void All_init()  //更新电路  大初始化 
{
	for(int i=1;i<=T;i++)
	{
		P[i].out=-1;
		in[i]=0;
		for(int j=1;j<=T;j++)
			M[i][j]=0;
	}
}
int Count(string s)  //计算 类似 I123 的123 
{
	int sum=0;
	int t=1;
	for(int i=s.size()-1;i>=1;i--)
		sum+=(s[i]-'0')*t,t*=10;
	return sum;
}
int find_ans(int num)  //找到某个逻辑电路所对应的输出 
{	
	if(P[num].out>=0)
	{
		return P[num].out;
	}
	int ans;
	int w=1;
	for(int i=1;i<=T;i++)
	{
		if(M[num][i])
		{
			int val=find_ans(i);
			if(w) //第一次进去，直接赋值 
			{
				ans=val;
				w=0;
				continue;
			}
			else //往后开始采用对应的操作 
			{
				
				switch(P[num].statu){
					case NOR:
					case OR:
						ans|= val;
						break;
					case NAND:
					case AND:
						ans&=val;
						break;
					case XOR:
						ans^=val;
						break;
				}
			}
			}	
	}
	switch(P[num].statu){  //对于最后取非的统一处理 
		case NOT:
		case NAND:
		case NOR:
			ans=!ans;
		default:
			break;
	}
	P[num].out=ans;
	return ans;
}
int Q;
int main()
{
	cin>>Q;
	while(Q--)  //按提示处理输入，这部分命名 的变量有点随意 
	{
		
		cin>>m>>N;
		k=m;
		T=k+N;
		init();
		string s,v;
		int x;
		for(int i=k+1;i<=T;i++)
		{
			cin>>s>>x;
			P[i].statu=Tra(s);
			while(x--)
			{
				cin>>v;
				if(v[0]=='I')
				{
					M[i][Count(v)]=1;
				}
				else
				{
					int g=Count(v)+k;
					M[i][g]=1;
					in[g]++;
				}
			}
		}
		bool tag;
		if(tag=Judge_c())
		{
			cout<<"LOOP"<<endl;  //这里还得继续读入，不然后面的数字会当成下一个电路的输入 
			}	
		int S;
		cin>>S;
		cin.get();//去掉换行 
		ostringstream fcout;
		for(int i=0;i<S;i++)
		{
		
			getline(cin,s);
			fcout<<s<<" ";
		}
		int fn=-1;
		istringstream fcin(fcout.str());
		
		
		for(int i=0;i<S;i++)
		{
			cin>>x;
			
			for(int j=1;j<=k;j++)
			{
				fcin>>P[j].out;
				
			}
			
			while(x--)
			{
				cin>>fn;
				if(!tag)
					cout<<find_ans(fn+k)<<" ";
			}
			if(!tag)
			{
			cout<<endl;
			init();
			}
		}
		All_init();
	}
	return 0;
}

第二份 代码长 时间短

#include<cstdio>
#include<iostream>
#include<vector>
#include<cstring>
#include<queue>
#include<algorithm>
#include<cstdlib>
using namespace std;
struct Point{
	int re;
	char *s;
};
int Q;

vector<int> G[501];
Point A[501];
int AA[501];
int visit[501];
int a=1;

int out[501];
vector<int> input_p[501];

vector<int> input[10001];
vector<int> output[10001];

void process_op()
{
	char *b,*c; 
	b=(char*)malloc(10);
	c=(char*)malloc(10);
	scanf("%s",b);
	A[a].s=b;
	int k;
	cin>>k;
	for(int i=1;i<=k;i++)
	{
		scanf("%s",c);
		if(c[0]=='I') 
		{
			int pon;
			char p;
			sscanf(c,"%c%d",&p,&pon);
			input_p[a].push_back(pon);
			
		}
		else 
		{
			int pon;
			char p;
			sscanf(c,"%c%d",&p,&pon);
			out[pon]++;
			G[a].push_back(pon);
		}
	}
	getchar();
	free(c);
	a++;
}

int search(int po)
{
	if(visit[po]==-1)
		return 0;
	visit[po]=1;
	
	vector<int>::iterator  it= G[po].begin();
	int sum=0;
	vector<int>k;
	while(it<G[po].end())
	{
		if(count(G[po].begin(),G[po].end(),*it)!=1)
		{
			if(find(k.begin(),k.end(),*it)!=k.end())
			{
				it++;
				continue;
			}
			else
			{
				k.push_back(*it);
			}
		}
		if(visit[*it]==1)
			return 1;
		else
			sum+=search(*it);
		it++;
	}
	
	visit[po]=-1;
	return sum;
}

bool judge(int n)
{
	queue<int>Q;
	for(int i=1;i<=n;i++)
		if(!out[i])
			Q.push(i);
	int num=0;
	while(!Q.empty())
	{
		int u=Q.front();
		Q.pop();
		num++;
		for(int i=0;i<G[u].size();i++)
		{
			if((--out[G[u][i]])==0)
				Q.push(G[u][i]); 
		}
	 }
	 return num!=n; 
	
}
int calculate(int po,vector<int> &list)
{
	if(AA[po])
		return A[po].re;
	AA[po]=1;
	char *p=A[po].s;
	if(!strcmp(p,"NOT"))
	{
		if(G[po].size())
		{
			int meta=G[po][0];
			A[po].re=!calculate(meta,list);
		}
		else
		{
					A[po].re=!list[input_p[po][0]];
		}
	}
	else if (!strcmp(p,"AND"))
	{
		int size=G[po].size();
		vector<int> val;
		for(int i=0;i<size;i++)
		{
			val.push_back(calculate(G[po][i],list));
		}
	
			if(input_p[po].size())
			{
				int k=input_p[po].size();
				while(k>0)
				val.push_back(list[input_p[po][--k]]);
				
			}
		
		int len=val.size();
		A[po].re=val[0];
		for(int i=1;i<len;i++)
		{
			A[po].re&=val[i];
		}

	}
	else if (!strcmp(p,"OR"))
	{
		int size=G[po].size();
		vector<int> val;
		for(int i=0;i<size;i++)
		{
			val.push_back(calculate(G[po][i],list));
		}
		
			if(input_p[po].size())
			{
				int k=input_p[po].size();
				while(k>0)
				val.push_back(list[input_p[po][--k]]);
				
			}
		
		int len=val.size();
		A[po].re=val[0];
		for(int i=1;i<len;i++)
		{
			A[po].re|=val[i];
		}

	}
	else if (!strcmp(p,"XOR"))
	{
		int size=G[po].size();
		vector<int> val;
		for(int i=0;i<size;i++)
		{
			val.push_back(calculate(G[po][i],list));
		}
	
			if(input_p[po].size())
			{
				int k=input_p[po].size();
				while(k>0)
				val.push_back(list[input_p[po][--k]]);
				
			}
		
		int len=val.size();
		A[po].re=val[0];
		for(int i=1;i<len;i++)
		{
			A[po].re^=val[i];
		}

	}
	else if (!strcmp(p,"NAND"))
	{
		int size=G[po].size();
		vector<int> val;
		for(int i=0;i<size;i++)
		{
			val.push_back(calculate(G[po][i],list));
		}
	
			if(input_p[po].size())
			{
				int k=input_p[po].size();
				while(k>0)
				val.push_back(list[input_p[po][--k]]);
				
			}
		
		int len=val.size();
		A[po].re=val[0];
		for(int i=1;i<len;i++)
		{
			A[po].re&=val[i];
		}
		A[po].re=!A[po].re;

	}
	else if (!strcmp(p,"NOR"))
	{

		int size=G[po].size();
		vector<int> val;
		for(int i=0;i<size;i++)
		{
			val.push_back(calculate(G[po][i],list));
		}
	
			if(input_p[po].size())
			{
				int k=input_p[po].size();
				while(k>0)
				val.push_back(list[input_p[po][--k]]);
				
			}
		
		int len=val.size();
		A[po].re=val[0];
		for(int i=1;i<len;i++)
		{
			
			A[po].re|=val[i];
		}
		A[po].re=!A[po].re;
	}
	return A[po].re;
}

void clear()
{
	for(int i=0;i<=500;i++)
	{
			G[i].clear();
			input_p[i].clear();
			out[i]=0;
			free(A[i].s);
	}
	memset(A,0,sizeof(A));
	memset(AA,0,sizeof(AA));
	memset(visit,0,sizeof(visit));
	for(int i=0;i<=10000;i++)
	{
		output[i].clear();
		input[i].clear() ;
		}
	a=1;
}

int main()
{
	cin>>Q;
	while(Q--)
	{
		
		int M,N;
		cin>>M>>N;
		int NN=N;
		while(NN--)
		{
			process_op();
		
		}
		int S;
		cin>>S;
		for(int i=1;i<=S;i++)
		{
			input[i].push_back(0);
			for(int j=1;j<=M;j++)
			{
				int l;
				cin>>l;
				input[i].push_back(l); 
			}
		 } 
		 for(int i=1;i<=S;i++)
		 {
		 	int b,v;
		 	cin>>b;
		 	for(int j=1;j<=b;j++)
		 	{
		 		cin>>v;
		 		output[i].push_back(v);
			 }		 	
		 }
		
		int sum=0;
		for(int i=1;i<=N;i++)
			sum+=search(i);
		if(sum)
		{
			cout<<"LOOP"<<endl;
			clear(); 
			continue;
		}
		
		/*
		if(judge(N))
		{
			cout<<"LOOP"<<endl;
			clear();
			continue;
		}
		*/
		for(int i=1;i<=S;i++)
		{
			for(int j=1;j<=N;j++)
			{
					calculate(j,input[i]);
			}
			int len=output[i].size();
			for(int j=0;j<len;j++)
			{
				cout<<(A[output[i][j]].re&1)<<" ";
			}
			cout<<endl;
			memset(AA,0,sizeof(AA));
		}
		clear();
	}
	return 0;
}
火枫木叶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CCF-201909-3-字符画
Aiven
12-10 662
这题大家有冷静看过的话，发现其实并不难。。考试和练习真的心态不一样啊。。。 题目大意： 把图片中的像素压缩成一些块，这个块的像素就是这些像素的平均值，然后再在控制台输入命令。还要把命令的每个字符转成ASCII码，16进制的。 # 题目大意：把图片压缩模糊后，再在控制台输出命令 # 题目使用空格作为字符作字符画，因为空格是透明的 # 所以其实只要改变终端背景色就ok了，就是48;2那个 # 所以38...
CCF CSP 2019_09 第三题 点亮数字人生
weixin_41447864的博客
03-23 326
CCF CSP真题刷题，做到2020年9月的真题，第三题：“点亮数字人生”的时候，遇到了奇怪的问题。 本人利用面向对象的方法实现了这道模拟题，自认为逻辑比较清晰了，不管使用什么网上的什么测试用例，代码均能通过。 但是提交CCF网站全部是 0 分，仔细检查过输出形式，没有发现有任何的不同，百思不得其解。 希望有大佬，能够帮忙指点一二。 测试用例 # 测试样例 1 1 3 5 XOR 2 I1 I2 XOR 2 O1 I3 AND 2 O1 I3 AND 2 I1 I2 OR 2 O3 O4 .
CCF认证201909-3字符画
weixin_38562500的博客
02-17 228
CCF认证201909-3字符画题目描述算法设计+题目分析注意点+记录点代码（100分）感谢链接 题目描述 201909-3字符画 算法设计+题目分析 吐槽一下 题目极其复杂，做的时候看了十几分钟题目愣是没看懂，去网上看了其他同学做的一些blog，还是没看懂。。。然后对着感谢链接里的同学的代码梳理了一下，才明白题目要干嘛，由于个人原因，只能在Visual C++ 6.0里操作，所以很多C++11的...
CSP CCF： 201909-3 字符画） （C++）
qq_45936312的博客
05-17 842
目录题目来源知识点20分 题目来源 字符画 知识点 C++头文件 #include <stdlib.h> 中的 system(“color xx”); system(“color XX”)函数可用于修改控制台背景及文字颜色。 第一个X是背景颜色，第二个X是前颜色。（都是16进制的单个字符） 在我写的代码中没有指明XX。就是默认的前白后黑了。 20分 数据特点： 解决方法： ...
CCF考试 201909-3 字符画C++100分简单易懂思路讲解。
weixin_45331809的博客
03-01 797
CCF考试 201909-3 字符画C++100分简单易懂思路讲解。使用的是C++11. 这个题的题干很长，其实有用的东西没几句话，我们不需要对含有字符的进行处理。只需要处理空格的那种情况就好了，也就是只需要对背景涂色就可以了。首先，我们声明了一个二维数组，用来存取输入的颜色。 然后，我们把他的缩写输入还原回来。都还原成长度为6的字符串（handleCon函数）。 然后我们就着手准备输出。我们要先...
CCFCSP真题 刷题 和真题分析.zip
最新发布
04-01
本压缩包文件"CCFCSP真题 刷题 和真题分析.zip"包含了丰富的资源，主要针对CCF CSP考试的备考者。其中，"CCFCSP真题 刷题 和真题分析"这部分内容可能包括历年真题集、模拟试题以及对这些试题的深入解析。通过刷题，...
CCF CSP认证资料
08-03
字符串处理上：lcs(最长公共子序列)，kmp（字符串匹配算法），复杂题设计思维+注释，类的设置，数据封装，多重嵌套解法。 图论算法上（目前出现过的）：设置高效的邻接表，dfs是基础，bfs（最优/短问题且各边权值为1...
ccf csp-j大纲（文字版）
08-30
ccf csp-j大纲（文字版）
CCFCSP 23年真题分析和答案解析.zip
04-01
总结来说，"CCFCSP 23年真题分析和答案解析.zip"是一个宝贵的资源，它包含的真题分析和编程实现可以帮助考生深入理解CCF CSP考试的考察内容，提升编程技能，并通过实践来检验和巩固自己的学习成果。对于准备参加或对...
ccfcsp历年考试真题解答(89页DOC)
03-31
ccfcsp历年考试真题解答。“CCF CSP历年考试真题解答”是一份极具价值的学习资料，它精选了CCF CSP（中国计算机学会软件能力认证）历年考试的真题，并提供了详尽的解答，总计89页，以DOC格式呈现。这份资料对于想要...
201909-3 字符画 CCF CCSP
AlenLoveCode的博客
04-04 156
主要是系统化，模块化设计，先想好表示数据的类型，格式，进而设计大概的逻辑结构，然后依次按输入模块，逻辑处理模块，输出模块来分析解决问题，以这样的思路去做题会好做很多。 #include<bits/stdc++.h> using namespace std; class Pixel{ //像素点的有关操作和属性定义 public: int R,G,B; Pixel(int r=0,int g=0,int b=0) { R=r; G=g; B=b; } bool o
ccf 201909-3 字符画（模拟）
smilng的博客
01-25 179
题外： 这个题的题意也太搞人心态了，光读题读了半个小时，感觉完全没说清楚，纯靠猜，而且那个前景有什么用最后也不知道，总之感觉难度都在读题上。 思路： 将读入的字符串处理成十进制的三个颜色，分别存储。 按p*q的块处理，得到块的平均颜色（平均时向下取整）。将颜色与上一个块的颜色last作比较（初始为默认值，全为0），若相同，直接输出空格，显示颜色，否则输出改变颜色的转义序列及一个空格并重置last。 输出一行后，输出一个换行符并将last设置为默认值。 注意：所有的符号需要转换为ASCII码再转换为.
CCF201909-3 字符画（100分）【文本处理】
海岛Blog
08-26 1142
试题编号： 201909-3 试题名称： 字符画 时间限制： 5.0s 内存限制： 512.0MB 问题链接：CCF201909-3 字符画 问题简述：（略） 问题分析：（略） 程序说明：（略） 参考链接：（略） 题记：（略） 100分的C++语言程序如下： /* CCF201909-3 字符画 */ #include <bits/stdc++.h> using namespace std; const int N = 1080; const int M = 1920; struc
ccf 字符画
surfing的博客
04-09 85
@ccf 字符画 #ccf 字符画 这个题我参考了别人的代码，但是只得了80分，下面我说一下自己的失误； ##失误 1.iomanip，iostream库比较好用，可用于转换，如iostream将输入转化为string，然后stringstream再通过hex将int(string->char)转换为十六进制数字的string表示； 2.最开始没读懂题意，这个题里面像素是逐个输入的，需要先逐个处理保存，string(int,char)可以对string进行扩展，非常好用； 3.16进制转10进制时讨论
CCF 201909-3 字符画
Nuage_1005的博客
11-03 894
201909-3 字符画 题目很难理解，准确来说是无关和迷惑的内容过多，所以审题并准确理解出题人想让你做的事真的很重要呐！为理顺思路，看了一些大牛写的代码（写的人不怎么多？？），自己写了程序，也测试了一下，貌似结果没问题（？？？），但是提交到系统就是错误。唉，本人愚笨，在此请路过的大牛们帮忙找找问题，先谢过了！ import java.util.Scanner; public class Mai...
ccf csp 2020年09月 第三题：点亮数字人生（dfs + 判环）
一只谜谜怪的博客
10-02 2851
题目背景 土豪大学的计算机系开了一门数字逻辑电路课，第一个实验叫做“点亮数字人生”，要用最基础的逻辑元件组装出实际可用的电路。时间已经是深夜了，尽管实验箱上密密麻麻的连线已经拆装了好几遍，小君同学却依旧没能让她的电路正常工作。你能帮助她模拟出电路的功能，成功点亮她的数字人生吗？ 问题描述 本题中，你需要实现一个简单的数字逻辑电路模拟器。如果你已经有了此方面的基础，可以直接跳过本节。在阅读时，也可以参照前两个样例的图示和解释，这有助于你更好地理解数字逻辑电路的工作原理。 数字逻辑电路是用来传输数字信号（也就是
【CSP】点亮数字人生（202009）
Danger的博客
10-17 2069
点亮数字人生（202009）（40）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值