问题描述
解题思路
拓扑排序(Topological Sort)
使用拓扑排序确定处理电路门的顺序。
大模拟
使用与(&)、或(|)、非(!)、异或(^)等操作模拟电路门，由输入信号得出输出信号。
作用域
这道题的输入格式很奇怪。先输入所有问题的电路门的结构，再输入所有问题的电路门的输入，最后输入所有的问题要输出的电路门编号。而不是一个个问题输入。
多次处理同一个问题时，巧妙地利用作用域（例如，将整个问题抽象成函数，将所有所需的变量封装在一个函数内），可以避免需要清理上个问题留下的数据的问题。
变量命名与注释
大模拟的题往往涉及很多相关的变量，变量命名应该尽量规范且贴合题意。退一步来说，最起码也得在变量定义处写好注释。
AC代码
C++
#include <stdio.h>
#include <vector>
#include <queue>
#include <string.h>
#include <algorithm>
using namespace std;
typedef struct Gate
{
char GateType[5];
bool OutputValue;
vector<int> InputList; //保存外界输入的信号编号
vector<int> GateInputList; //保存依赖于其他电路门输出的输入信号
vector<int> OutputList;
} Gate;
bool TopLogicalSort(const vector<Gate> &GateList, vector<int> &Indgree, int GateNum, vector<int> &TopLogicalGateList)
{
//GateNoListTemp暂存拓扑排序的部分序列
queue<int> GateNoListTemp;
for (int i = 1; i <= GateNum; ++i)
{
//入度为0的门无需依赖于其他门，放入GateNoListTemp
if (Indgree[i] == 0)
{
GateNoListTemp.push(i);
}
}
while (GateNoListTemp.empty() == false)
{
//队首的门的编号放入拓扑序列
TopLogicalGateList.push_back(GateNoListTemp.front());
//取出排在队首的门的编号
Gate GateTemp = GateList[GateNoListTemp.front()];
GateNoListTemp.pop();
//对下一个门的入度减一
for (int i = 0; i < GateTemp.OutputList.size(); ++i)
{
//若下一个门的入度为0，放入GateNoListTemp
if (--Indgree[GateTemp.OutputList[i]] == 0)
{
GateNoListTemp.push(GateTemp.OutputList[i]);
}
}
}
return TopLogicalGateList.size() == GateNum;
}
void Imitate(vector<Gate> &GateList, const vector<int> &TopLogicalGateList, int SubProblemNum, const vector<vector<int>> &InputSignal, const vector<int> &OutputSignalNum, const vector<vector<int>> &OutputSignal)
{
for (int SubProblemNo_i = 0; SubProblemNo_i < SubProblemNum; ++SubProblemNo_i)
{
//根据拓扑序列，使用输入得出输出
for (int GateNo_i = 0; GateNo_i < TopLogicalGateList.size(); ++GateNo_i)
{
Gate Temp = GateList[TopLogicalGateList[GateNo_i]];
//根据门的类型分别进行处理
if (Temp.GateType[0] == 'N' && Temp.GateType[2] == 'T') //非门NOT
{
if (Temp.InputList.empty() == true)
Temp.OutputValue = (!GateList[Temp.GateInputList[0]].OutputValue);
else
Temp.OutputValue = (!InputSignal[SubProblemNo_i][Temp.InputList[0]]);
}
else if (Temp.GateType[0] == 'A') //与门AND
{
Temp.OutputValue = true;
for (int i = 0; i < Temp.InputList.size(); ++i)
{
Temp.OutputValue &= InputSignal[SubProblemNo_i][Temp.InputList[i]];
}
for (int i = 0; i < Temp.GateInputList.size(); ++i)
{
Temp.OutputValue &= GateList[Temp.GateInputList[i]].OutputValue;
}
}
else if (Temp.GateType[0] == 'O') //或门OR
{
Temp.OutputValue = false;
for (int i = 0; i < Temp.InputList.size(); ++i)
{
Temp.OutputValue |= InputSignal[SubProblemNo_i][Temp.InputList[i]];
}
for (int i = 0; i < Temp.GateInputList.size(); ++i)
{
Temp.OutputValue |= GateList[Temp.GateInputList[i]].OutputValue;
}
}
else if (Temp.GateType[0] == 'X') //异或门XOR
{
Temp.OutputValue = false;
for (int i = 0; i < Temp.InputList.size(); ++i)
{
Temp.OutputValue ^= InputSignal[SubProblemNo_i][Temp.InputList[i]];
}
for (int i = 0; i < Temp.GateInputList.size(); ++i)
{
Temp.OutputValue ^= GateList[Temp.GateInputList[i]].OutputValue;
}
}
else if (Temp.GateType[0] == 'N' && Temp.GateType[1] == 'A') //与非门NAND
{
Temp.OutputValue = true;
for (int i = 0; i < Temp.InputList.size(); ++i)
{
Temp.OutputValue &= InputSignal[SubProblemNo_i][Temp.InputList[i]];
}
for (int i = 0; i < Temp.GateInputList.size(); ++i)
{
Temp.OutputValue &= GateList[Temp.GateInputList[i]].OutputValue;
}
Temp.OutputValue = !Temp.OutputValue; //先算与运算，最后取反
}
else if (Temp.GateType[0] == 'N' && Temp.GateType[2] == 'R') //或非门NOR
{
Temp.OutputValue = false;
for (int i = 0; i < Temp.InputList.size(); ++i)
{
Temp.OutputValue |= InputSignal[SubProblemNo_i][Temp.InputList[i]];
}
for (int i = 0; i < Temp.GateInputList.size(); ++i)
{
Temp.OutputValue |= GateList[Temp.GateInputList[i]].OutputValue;
}
Temp.OutputValue = !Temp.OutputValue; //先算或运算，最后取反
}
GateList[TopLogicalGateList[GateNo_i]].OutputValue = Temp.OutputValue;
}
//依次输出
for (int OutputSignalNo_i = 0; OutputSignalNo_i < OutputSignalNum[SubProblemNo_i]; ++OutputSignalNo_i)
{
int OutputSignalNo = OutputSignal[SubProblemNo_i][OutputSignalNo_i];
printf("%d ", GateList[OutputSignalNo].OutputValue);
}
putchar('\n');
}
}
int main()
{
int ProblemNum = 0;
scanf("%d", &ProblemNum);
//依次处理每个问题
for (int ProblemNo_i = 0; ProblemNo_i < ProblemNum; ++ProblemNo_i)
{
//输入输入信号的数量和电路门的数量
int InputSignalNum, GateNum;
scanf("%d%d", &InputSignalNum, &GateNum);
vector<Gate> GateList(GateNum + 1); //电路门数组
vector<int> GateIndgree(GateNum + 1, 0); //电路门的入度
//对每个门的输入信号都进行输入
for (int GateNo_i = 1; GateNo_i <= GateNum; ++GateNo_i)
{
int GateSignalNum;
//输入电路门的类型和电路门输入信号的数量
scanf("%s %d ", GateList[GateNo_i].GateType, &GateSignalNum);
//对输入的信号进行处理
for (int GateSignalNo_i = 0; GateSignalNo_i < GateSignalNum; ++GateSignalNo_i)
{
char GateInputSignalType = getchar(); // 'I' or 'O'
int SignalNo;
scanf("%d", &SignalNo); //信号编号
getchar(); //deal with the ' ' and '\n'
if (GateInputSignalType == 'I') //外界输入的信号编号
GateList[GateNo_i].InputList.push_back(SignalNo);
else //依赖于其他电路门输出的输入信号
{
GateList[GateNo_i].GateInputList.push_back(SignalNo);
GateList[SignalNo].OutputList.push_back(GateNo_i);
++GateIndgree[GateNo_i];
}
}
}
int SubProblemNum;
scanf("%d", &SubProblemNum);
//为每个子问题的输入信号值分配存储空间
vector<vector<int>> InputSignal(SubProblemNum);
//输入每个子问题的数据
for (int SubProblemNo_i = 0; SubProblemNo_i < SubProblemNum; ++SubProblemNo_i)
{
InputSignal[SubProblemNo_i].push_back(0);
for (int InputSignalNo_i = 1; InputSignalNo_i <= InputSignalNum; ++InputSignalNo_i)
{
int SignalValue;
scanf("%d", &SignalValue);
InputSignal[SubProblemNo_i].push_back(SignalValue);
}
}
vector<int> OutputSignalNum(SubProblemNum);
vector<vector<int>> OutputSignal(SubProblemNum);
//输入每个子问题需要输出的信号
for (int SubProblemNo_i = 0; SubProblemNo_i < SubProblemNum; ++SubProblemNo_i)
{
scanf("%d", &OutputSignalNum[SubProblemNo_i]);
for (int OutputSignalNo_i = 0; OutputSignalNo_i < OutputSignalNum[SubProblemNo_i]; ++OutputSignalNo_i)
{
int SignalValue;
scanf("%d", &SignalValue);
OutputSignal[SubProblemNo_i].push_back(SignalValue);
}
}
vector<int> TopLogicalGateList;
//拓扑排序：判环
if (TopLogicalSort(GateList, GateIndgree, GateNum, TopLogicalGateList) == false)
{
printf("LOOP\n");
continue;
}
Imitate(GateList, TopLogicalGateList, SubProblemNum, InputSignal, OutputSignalNum, OutputSignal);
}
return 0;
}
python
这一份只有50分，找不到错。
class Gate:
def __init__(self):
self.type = ""
self.in_degree = 0
self.input_sig = []
self.input_gate = []
self.output_gate = []
def topological_sort(gate_num, gate_list):
temp_queue = []
topological_order = []
for i in range(gate_num):
if gate_list[i].in_degree == 0:
temp_queue.append(i)
while temp_queue:
temp = temp_queue.pop(0)
topological_order.append(temp)
output_gate = gate_list[temp].output_gate
for i in output_gate:
gate_list[i].in_degree -= 1
if gate_list[i].in_degree == 0:
temp_queue.append(i)
return topological_order
def imitation(topological_order, gate_list, input_signal, output_signal):
for gate_No in topological_order:
temp_gate = gate_list[gate_No]
gate_type = temp_gate.type
input_sig = temp_gate.input_sig
input_gate = temp_gate.input_gate
result = 1
if gate_type == "NOT":
if not input_gate:
result = 1 ^ input_signal[input_sig[0]]
else:
result = 1 ^ output_signal[input_gate[0]]
elif gate_type == "AND":
for sig_i in input_sig:
result &= input_signal[sig_i]
for sig_i in input_gate:
result &= output_signal[sig_i]
elif gate_type == "OR":
result = 0
for sig_i in input_sig:
result |= input_signal[sig_i]
for sig_i in input_gate:
result |= output_signal[sig_i]
elif gate_type == "XOR":
result = 0
for sig_i in input_sig:
result ^= input_signal[sig_i]
for sig_i in input_gate:
result ^= output_signal[sig_i]
elif gate_type == "NAND":
for sig_i in input_sig:
result &= input_signal[sig_i]
for sig_i in input_gate:
result &= output_signal[sig_i]
result = 1 ^ result
else: # gate_type == "NOR":
result = 0
for sig_i in input_sig:
result |= input_signal[sig_i]
for sig_i in input_gate:
result |= output_signal[sig_i]
result = 1 ^ result
output_signal[gate_No] = result
if __name__ == "__main__":
question_num = int(input())
for question_i in range(question_num):
line_info = input().split()
input_sig_num = int(line_info[0])
gate_num = int(line_info[1])
if not gate_num: # test5
continue
gate_list = [Gate() for i in range(gate_num)]
for gate_i in range(gate_num):
line_info = input().split()
gate_type = line_info[0]
gate_list[gate_i].type = gate_type
gate_input_num = int(line_info[1])
for gate_input_sig_i in range(gate_input_num):
input_sig_type = line_info[2 + gate_input_sig_i][0]
input_sig = int(line_info[2 + gate_input_sig_i][1:]) - 1
if input_sig_type == "I":
gate_list[gate_i].input_sig.append(input_sig)
else:
gate_list[gate_i].input_gate.append(input_sig)
gate_list[gate_i].in_degree += 1
gate_list[input_sig].output_gate.append(gate_i)
topological_order = topological_sort(gate_num, gate_list)
imitation_times = int(input())
input_signal = []
output_signal = []
if input_sig_num:
for imitation_i in range(imitation_times):
input_sig_i = input().split()
input_sig_i = [int(i) for i in input_sig_i]
input_signal.append(input_sig_i)
else:
input_signal = [[] * imitation_times]
for imitation_i in range(imitation_times):
output_sig_i = input().split()
output_sig_i = [int(i) for i in output_sig_i]
output_sig_i.pop(0)
output_signal.append(output_sig_i)
if len(topological_order) != gate_num:
print("LOOP")
continue
for imitation_i in range(imitation_times):
input_sig_i = input_signal[imitation_i]
output_sig_i = output_signal[imitation_i]
if output_sig_i == [] or output_sig_i[0] == 0:
continue
output_signal_i = [0] * gate_num
imitation(topological_order, gate_list, input_sig_i, output_signal_i)
ans = []
for output_sig in output_sig_i:
ans.append(str(output_signal_i[output_sig - 1]))
print(" ".join(ans))
2315
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
