CSP202009-3 点亮数字人生

最新推荐文章于 2024-03-23 14:28:43 发布
最新推荐文章于 2024-03-23 14:28:43 发布
阅读量717 收藏 6
点赞数
CC 4.0 BY-SA版权
分类专栏： 练习题目 文章标签： 数据结构 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_43381135/article/details/112990370
该博客详细解析了一道关于图论和电路模拟的CSP竞赛题目，涉及图论节点数据结构、拓扑排序、逻辑门器件模拟等。博主首先介绍了如何将逻辑器件抽象成图论节点，接着讲解了主函数如何读取输入、建立图并判断环。拓扑排序用于检测环的存在，若发现环则输出'LOOP'，否则模拟电路输出器件状态。此外，还提供了六种逻辑门器件的工作代码实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

CSP202009-3 点亮数字人生

题目

题目可以在CSP的官网上找到哟！

算法思想

这道题看上去花里胡哨的，其实本质上是一个有关图论和小模拟的题目，模拟规模不大，所涉及到的图论的难度也不高。题目首先要求查看是否出现带环的电路，我们可以将逻辑器件抽象成图论中的节点，然后通过拓扑排序即可判断是否出现环。如果出现环，则直接输出“LOOP”即可；如果没有出现环，则根据输入形式按照输出形式，输出需要的器件的状态，这个可以从所需要的节点进行递归调用，求解出器件的状态值。
结果

代码详解

1、图论节点数据结构

每一个逻辑门器件都抽象成图论中的节点，具体代码如下：

struct node
{
	int type;       //节点种类对应着不同种类的器件 
	int output;     //器件的输出状态值
	int input_num;  //连接该器件的输入信号数量
	int input[6];   //存储连接该器件的输入信号的序号
}Node[3005];
2、主函数

主函数的功能主要是按照输入格式将输入信息读取出来，并按照信号的连接方式进行建图，建图之后首先判断是否含有环，是用拓扑排序的思想进行判断环，如果存在环，则直接输出"LOOP"即可；如果不存在环，则按照输出格式的要求，运行电路，输出所需要的器件的状态值。
具体的代码如下：

int main()
{
	freopen("in.in", "r", stdin);
	freopen("out.out", "w", stdout);
	int ii, i, j, k;
	cin >> q;          
	for (ii = 1; ii <= q; ii++)
	{
		cin >> m >> n;
		for (i = 0; i < m; i++)
		{
			Node[i].type = 0;
			Node[i].output = -1;
		}
		memset(d, 0, sizeof(d));
		for (i = 0; i < n; i++)
		{
			Node[m + i].output = -1;
			string fun_type;
			cin >> fun_type;
			//区分不同种类的器件
			if (fun_type == "NOT") {
				Node[m + i].type = 1;
			}
			else if (fun_type == "AND") {
				Node[m + i].type = 2;
			}
			else if (fun_type == "OR") {
				Node[m + i].type = 3;
			}
			else if (fun_type == "XOR") {
				Node[m + i].type = 4;
			}
			else if (fun_type == "NAND") {
				Node[m + i].type = 5;
			}
			else if (fun_type == "NOR") {
				Node[m + i].type = 6;
			}
			int fun_num;
			cin >> fun_num;
			Node[m + i].input_num = fun_num;
			for (j = 0; j < fun_num; j++)   //存储器件的输入信号
			{
				string input_num;
				cin >> input_num;
				int num = 0;
				for (k = 1; k < input_num.length(); k++)
					num = num * 10 + (input_num[k] - '0');
				if (input_num[0] == 'I') {
					Node[m + i].input[j] = num - 1;
				}
				else if (input_num[0] == 'O') {
					Node[m + i].input[j] = num - 1 + m;
					d[num - 1]++;
				}
			}
		}
		cin >> s;
		for (i = 0; i < s; i++)
		{
			for (j = 0; j < m; j++)
			{
				cin >> inp[i][j];
			}
		}
		int si;
		int oi;
		if (CheckCircle())   //存在环，正常输入，直接输出"LOOP"
		{
			for (i = 0; i < s; i++)
			{
				cin >> si;
				for (j = 0; j < si; j++)
					cin >> oi;
			}
			cout << "LOOP" << endl;
		}
		else  //没有环，继续进行模拟
		{
			for (i = 0; i < s; i++)
			{
				cin >> si;
				for (j = 0; j < m; j++)
					Node[j].output = inp[i][j];
				for (j = 0; j < n; j++)
					Node[m + j].output = -1;
				for (j = 0; j < si; j++)
				{
					cin >> oi;
					cout << work(m + oi - 1) << " ";
				}
				cout << endl;
			}
		}
	}
	return 0;
}
3、拓扑排序判断是否存在环

拓扑排序判断是否有环的主要思想就是：根据建成的图结构，统计每一个节点的入度，将每一个入读为0的节点删去，重新调整其余节点的入度，一直循环下去，如果最后入读全为0，则说明该图形结构中没有环的出现；如果最后有入度不为0的节点，则说明图形结构中出现了环。
具体的代码如下：

int CheckCircle()
{
	int i;
	queue<int>qu;
	bool ans = false;
	for (i = 0; i < n; i++)
		if (d[i] == 0) qu.push(i);
	while (!qu.empty())
	{
		int v = qu.front();
		qu.pop();
		for (i = 0; i < Node[m + v].input_num; i++)
		{
			if (Node[m + v].input[i] >= m)
			{
				d[Node[m + v].input[i] - m]--;
				if (d[Node[m + v].input[i] - m] == 0) qu.push(Node[m + v].input[i] - m);
			}
		}
	}
	for (i = 0; i < n; i++)
		if (d[i] != 0) ans = true;
	return ans;
}
4、电路的模拟

本题中设计到六种逻辑器件的模拟，我们只需要对这六种不同的逻辑器件按照其实际的逻辑功能进行计算即可，具体的代码如下：

int NOTwork(int num)
{
	if (Node[num].output == -1)
		Node[num].output = !work(Node[num].input[0]);
	return Node[num].output;
}
int ANDwork(int num)
{
	int ans = 1, i;
	if (Node[num].output == -1)
	{
		for (i = 0; i < Node[num].input_num; i++)
		{
			ans = ans & work(Node[num].input[i]);
		}
		Node[num].output = ans;
	}
	return Node[num].output;
}
int ORwork(int num)
{
	int ans = 0, i;
	if (Node[num].output == -1)
	{
		for (i = 0; i < Node[num].input_num; i++)
		{
			ans = ans | work(Node[num].input[i]);
		}
		Node[num].output = ans;
	}
	return Node[num].output;
}
int XORwork(int num)
{
	int ans, i;
	if (Node[num].output == -1)
	{
		ans = work(Node[num].input[0]);
		for (i = 1; i < Node[num].input_num; i++)
		{
			ans = ans ^ work(Node[num].input[i]);
		}
		Node[num].output = ans;
	}
	return Node[num].output;
}
int NANDwork(int num)
{
	int ans = 1, i;
	if (Node[num].output == -1)
	{
		for (i = 0; i < Node[num].input_num; i++)
		{
			ans = ans & work(Node[num].input[i]);
		}
		Node[num].output = !ans;
	}
	return Node[num].output;
}
int NORwork(int num)
{
	int ans = 0, i;
	if (Node[num].output == -1)
	{
		for (i = 0; i < Node[num].input_num; i++)
		{
			ans = ans | work(Node[num].input[i]);
		}
		Node[num].output = !ans;
	}
	return Node[num].output;
}
int work(int num)
{
	if (Node[num].type == 0) {
		return Node[num].output;
	}
	else if (Node[num].type == 1) {
		return NORwork(num);
	}
	else if (Node[num].type == 2) {
		return ANDwork(num);
	}
	else if (Node[num].type == 3) {
		return ORwork(num);
	}
	else if (Node[num].type == 4) {
		return XORwork(num);
	}
	else if (Node[num].type == 5) {
		return NANDwork(num);
	}
	else if (Node[num].type == 6) {
		return NORwork(num);
	}
	else return -1;
}

完整代码

#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#include<queue>
#pragma warning (disable:4996)
using namespace std;
int q;
int n, m; //m:输入信号的数量; n:器件数量
int s;
struct node
{
	int type;       //节点种类对应着不同种类的器件 
	int output;     //器件的输出状态值
	int input_num;  //连接该器件的输入信号数量
	int input[6];   //存储连接该器件的输入信号的序号
}Node[3005];
int d[3005];
int inp[10000][10000];
int work(int num);
int CheckCircle()
{
	int i;
	queue<int>qu;
	bool ans = false;
	for (i = 0; i < n; i++)
		if (d[i] == 0) qu.push(i);
	while (!qu.empty())
	{
		int v = qu.front();
		qu.pop();
		for (i = 0; i < Node[m + v].input_num; i++)
		{
			if (Node[m + v].input[i] >= m)
			{
				d[Node[m + v].input[i] - m]--;
				if (d[Node[m + v].input[i] - m] == 0) qu.push(Node[m + v].input[i] - m);
			}
		}
	}
	for (i = 0; i < n; i++)
		if (d[i] != 0) ans = true;
	return ans;
}
int NOTwork(int num)
{
	if (Node[num].output == -1)
		Node[num].output = !work(Node[num].input[0]);
	return Node[num].output;
}
int ANDwork(int num)
{
	int ans = 1, i;
	if (Node[num].output == -1)
	{
		for (i = 0; i < Node[num].input_num; i++)
		{
			ans = ans & work(Node[num].input[i]);
		}
		Node[num].output = ans;
	}
	return Node[num].output;
}
int ORwork(int num)
{
	int ans = 0, i;
	if (Node[num].output == -1)
	{
		for (i = 0; i < Node[num].input_num; i++)
		{
			ans = ans | work(Node[num].input[i]);
		}
		Node[num].output = ans;
	}
	return Node[num].output;
}
int XORwork(int num)
{
	int ans, i;
	if (Node[num].output == -1)
	{
		ans = work(Node[num].input[0]);
		for (i = 1; i < Node[num].input_num; i++)
		{
			ans = ans ^ work(Node[num].input[i]);
		}
		Node[num].output = ans;
	}
	return Node[num].output;
}
int NANDwork(int num)
{
	int ans = 1, i;
	if (Node[num].output == -1)
	{
		for (i = 0; i < Node[num].input_num; i++)
		{
			ans = ans & work(Node[num].input[i]);
		}
		Node[num].output = !ans;
	}
	return Node[num].output;
}
int NORwork(int num)
{
	int ans = 0, i;
	if (Node[num].output == -1)
	{
		for (i = 0; i < Node[num].input_num; i++)
		{
			ans = ans | work(Node[num].input[i]);
		}
		Node[num].output = !ans;
	}
	return Node[num].output;
}
int work(int num)
{
	if (Node[num].type == 0) {
		return Node[num].output;
	}
	else if (Node[num].type == 1) {
		return NORwork(num);
	}
	else if (Node[num].type == 2) {
		return ANDwork(num);
	}
	else if (Node[num].type == 3) {
		return ORwork(num);
	}
	else if (Node[num].type == 4) {
		return XORwork(num);
	}
	else if (Node[num].type == 5) {
		return NANDwork(num);
	}
	else if (Node[num].type == 6) {
		return NORwork(num);
	}
	else return -1;
}
int main()
{
	freopen("in.in", "r", stdin);
	freopen("out.out", "w", stdout);
	int ii, i, j, k;
	cin >> q;          
	for (ii = 1; ii <= q; ii++)
	{
		cin >> m >> n;
		for (i = 0; i < m; i++)
		{
			Node[i].type = 0;
			Node[i].output = -1;
		}
		memset(d, 0, sizeof(d));
		for (i = 0; i < n; i++)
		{
			Node[m + i].output = -1;
			string fun_type;
			cin >> fun_type;
			//区分不同种类的器件
			if (fun_type == "NOT") {
				Node[m + i].type = 1;
			}
			else if (fun_type == "AND") {
				Node[m + i].type = 2;
			}
			else if (fun_type == "OR") {
				Node[m + i].type = 3;
			}
			else if (fun_type == "XOR") {
				Node[m + i].type = 4;
			}
			else if (fun_type == "NAND") {
				Node[m + i].type = 5;
			}
			else if (fun_type == "NOR") {
				Node[m + i].type = 6;
			}
			int fun_num;
			cin >> fun_num;
			Node[m + i].input_num = fun_num;
			for (j = 0; j < fun_num; j++)   //存储器件的输入信号
			{
				string input_num;
				cin >> input_num;
				int num = 0;
				for (k = 1; k < input_num.length(); k++)
					num = num * 10 + (input_num[k] - '0');
				if (input_num[0] == 'I') {
					Node[m + i].input[j] = num - 1;
				}
				else if (input_num[0] == 'O') {
					Node[m + i].input[j] = num - 1 + m;
					d[num - 1]++;
				}
			}
		}
		cin >> s;
		for (i = 0; i < s; i++)
		{
			for (j = 0; j < m; j++)
			{
				cin >> inp[i][j];
			}
		}
		int si;
		int oi;
		if (CheckCircle())   //存在环，正常输入，直接输出"LOOP"
		{
			for (i = 0; i < s; i++)
			{
				cin >> si;
				for (j = 0; j < si; j++)
					cin >> oi;
			}
			cout << "LOOP" << endl;
		}
		else  //没有环，继续进行模拟
		{
			for (i = 0; i < s; i++)
			{
				cin >> si;
				for (j = 0; j < m; j++)
					Node[j].output = inp[i][j];
				for (j = 0; j < n; j++)
					Node[m + j].output = -1;
				for (j = 0; j < si; j++)
				{
					cin >> oi;
					cout << work(m + oi - 1) << " ";
				}
				cout << endl;
			}
		}
	}
	return 0;
}
【CSP】202009-3点亮数字人生(拓扑排序)
weixin_45720246的博客
12-19 471
本题并不难，主要在于将电路连接图抽象为有向图，然后进行简单拓扑排序即可，下文给出代码在已在几个点给出注释 /* * @Author: csc * @Date: 2020-12-14 17:29:08 * @LastEditTime: 2020-12-19 19:10:17 * @LastEditors: Please set LastEditors * @Description: In User Settings Edit * @FilePath: \code\csp\2009_3.cpp..
CCF-CSP 202009-3 点亮数字人生 拓扑排序+模拟
M_theory004的博客
10-11 657
#include<bits/stdc++.h> using namespace std; typedef long long ll; template<class T> inline bool scan_d(T &ret) { char c; int sgn; if(c = getchar(),c==EOF) return 0; while(c!='-'&&(c<'0'||c>'9')) ...
第 20 次 CSP认证 202009-3 点亮数字人生代码
qq_44103902的博客
09-15 765
题目 ac的代码搞不到了，凭印象大概写了下，应该是对的吧，应该… #include <bits/stdc++.h> using namespace std; #define int long long #define Log //日志开关 bool isLoop = false; struct Gate{ #ifdef Log string name; #endif vector<Gate* > inputs; bool output;
【CSP】2020-09-3 点亮数字人生 （拓扑排序+大模拟）
最新发布
m0_65708726的博客
03-23 887
记录了本人刷csp过程中的发现的错误、解题过程和收获，希望会你对解题和学习有一定的帮助。
CCF CSP202009-3 点亮数字人生 (AC100分)(拓扑排序(判环)+链式前向星存图+模拟)
u011902923的博客
09-30 1305
在考场上很遗憾，由于平时练习，很缺少处理多组数据输入输出的经验，以及考场严重设备问题，这样一份白给的题出了很多很多错，其思维难度其实很低，但是并没有debug成功，很可惜，与当前一模一样的思路，可惜只拿了20分QAQ。 也非常令人感慨，无论是OI竞赛还是真正处理工程问题中，其实一些微小的错误就能让你为之停留很久，花费很多不必要的时间。 ①首先是多组数据输入时的初值(初始化是个好习惯) ②其次考场时的思路太杂乱、太跳脱了，并没有很好的顺着题意往下走，导致部分地方写的更复杂。 是人总是会犯错的，但有没有什么办法
CCF CSP202009-3点亮数字人生（c++100）
qq_44091681的博客
12-09 997
CCF CSP202009-4星际旅行 1、利用入度计算拓扑序列，不能拓扑序列就是有环，存储的点为输入为n，元器件为n+m 2、根据拓扑序列计算每个元器件所需的输入的值 3、输出相应元器件的值 #include<bits/stdc++.h> using namespace std; const int maxn = 3010; vector<int>G[maxn],line,V[maxn]; string op[maxn]; int ans[10010][maxn],degree[m
CCF 202009-3点亮数字人生 （100分）
Henimal00的博客
09-29 2501
（1）题目描述 （2）算法思想 本题难度其实不大，关键是耐心读题。 首先剖析一下题目的输入顺序以及格式： 1 //要解决的问题数目，本题由多个独立的子问题构成 3 5 //独立问题的电路输入个数以及器件个数 XOR 2 I1 I2 //器件类型、输入个数、每个输入端的编号，I开头表示直接输入，O开头表示器件输入 XOR 2 O1 I3 AND 2 O1 I3 AND 2 I1 I2 OR 2 O3 O4 4 //输入的次数，也即输出的次数 0 1 1 //每次输入时输入信号的状态 1 0 1
点亮数字人生（思路+代码）
Barry的博客
10-17 1058
思路： 抽象成图的问题 定义邻接表数据结构并初始化 typedef struct Node{ int v;//边的终点 Node(int _v):v(_v){}//初始化列表 }node; std::vector<node> Adj[MAXV];//邻接表 审题： 1.因为题目中包含Q个问题，所以存放数据的结构每次循环开始的时候都要进行初始化。 2.输入分为两部分，顺序读入。 3.第一部分： （1）第一行M、N表示整个电路的输入和器件的数量，N最大是500， （2）接下来N行（
第 20 次 CSP认证-202009-Java-点亮数字人生（亮不起来T_T）（内附代码和若干测试用例）
H_X_P_的博客
09-14 1838
第 20 次 CSP认证-202009-Java-点亮数字人生（内附代码）
2017011429_张程远_点亮数字人生1
08-03
1、通过数码管点亮程序，熟悉 VHDL 语言，了解掌握硬件程序的编写规范 2、掌握 EDA 软件的使用方法和工作流程 3、进一步理解可编程芯片的工作原理 1、同
第 20 次 CSP认证-202009-Java-风险人群筛查（100分）
H_X_P_的博客
09-14 1075
第 20 次 CSP认证-202009-Java-风险人群筛查（100分）
ccf csp 2020年09月 第三题：点亮数字人生（dfs + 判环）
一只谜谜怪的博客
10-02 3007
题目背景 土豪大学的计算机系开了一门数字逻辑电路课，第一个实验叫做“点亮数字人生”，要用最基础的逻辑元件组装出实际可用的电路。时间已经是深夜了，尽管实验箱上密密麻麻的连线已经拆装了好几遍，小君同学却依旧没能让她的电路正常工作。你能帮助她模拟出电路的功能，成功点亮她的数字人生吗？ 问题描述 本题中，你需要实现一个简单的数字逻辑电路模拟器。如果你已经有了此方面的基础，可以直接跳过本节。在阅读时，也可以参照前两个样例的图示和解释，这有助于你更好地理解数字逻辑电路的工作原理。 数字逻辑电路是用来传输数字信号（也就是
【CSP】点亮数字人生（202009）
Danger的博客
10-17 2239
点亮数字人生（202009）（40）
第 20 次 CSP认证 202009-3 点亮数字人生
Running Snail
09-14 1914
样例一输入： 1 3 5 XOR 2 I1 I2 XOR 2 O1 I3 AND 2 O1 I3 AND 2 I1 I2 OR 2 O3 O4 4 0 1 1 1 0 1 1 1 1 0 0 0 2 5 2 2 5 2 2 5 2 2 5 2 样例二输入： 1 2 6 NOR 2 O4 I2 AND 2 O4 O6 XOR 2 O5 O1 NOT 1 O6 NAND 2 O2 O2 AND 2 I1 O3 2 0 0 1 0 3 2 3 4 6 1 2 3 4 5 6 ...
CSP 202009-3 点亮数字人生
旺崽的博客
03-19 2209
题目链接 建图 + DFS~ 题目比较简单，首先确定的是要建图的，那么对每个结点我们应该存哪些信息呢？我的结构体如下： kind，记录结点的元件种类 val，记录元件的输入信号 father，记录元件的父亲个数，这个我个人认为非常重要，因为在找环的时候，我们可以记录每个结点的遍历次数 cnt，若 cnt > father 证明图中一定出现了环 son，记录元件儿子结点的编号 这题因为所有元件的种类和编号固定，且编号不重复，所以可以直接用 map 对元件进行编号~ 至于求元件的值，直接用 DFS
CCF CSP 202009-3 点亮数字人生-详细注释版
sum___mer的博客
04-08 520
CCF CSP 202009-3 点亮数字人生-详细注释版 #include <iostream> // 直接到拉到最下方 主函数 #include <cstring> #include <algorithm> #include <unordered_map> #include <unordered_set> #include <cmath> #include <map> #include <set> #inc
CSP CCF：202009-3 点亮数字人生 （C++）
qq_45936312的博客
05-03 1170
纯记录一下， 感兴趣的请移步大佬博客
CCF CSP 点亮数字人生（100分）
weixin_44647458的博客
04-09 490
CCF CSP 点亮数字人生（100分） 点亮数字人生 通过拓扑排序判断是否有环 "dfs+记忆化搜索"得出目标器件的输出 #include<iostream> #include<string> #include<vector> #include<map> #include<queue> using namespace std; const int maxn=505; //Nmax:器件最大数量 const int maxs=10005;
CSP 2019-J2信息学奥赛题解：数字游戏与交通换乘
2019年的CSP-J2复赛中包含了一些典型的问题，如数字游戏、交通换乘和纪念品等。 首先，我们来看T1数字游戏。这是一个字符串处理问题，要求读入一个字符串并统计其中数字“1”的个数。程序中通过遍历字符串，检查每...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值