CSP CCF：202009-3 点亮数字人生 （C++）

已于 2022-05-04 16:29:20 修改
阅读量961 收藏 1
点赞数 1
分类专栏： csp 文章标签： c++
于 2022-05-03 16:57:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45936312/article/details/124556856
版权
博客内容涉及利用C++实现有向无环图（DAG）的拓扑排序，以及在该场景下进行逻辑门计算。通过解析输入的逻辑门器件及其连接关系，构建邻接表，并检查是否存在环路。在无环路的情况下，根据层级对器件进行排序，然后逐层计算器件的输出，最终输出指定输入条件下的结果。博客中还讨论了代码中出现的问题及改进过程，包括细节处理和性能优化。
摘要由CSDN通过智能技术生成

目录

纯记录一下， 感兴趣的请移步大佬博客

题目来源

http://118.190.20.162/view.page?gpid=T111

大佬博客

层级：https://blog.csdn.net/qq_44528283/article/details/109501132
拓扑排序：https://blog.csdn.net/qq_44528283/article/details/113446330

层级： 根据大佬的代码写得 （0分）(自己没注意细节）

#include <iostream>
#include <string.h>
#include <vector>
#include <map>
#include <algorithm>
#include <sstream>

using namespace std;

struct device {
    int id;                  // 器件编号
    string type;             // 器件类型
    bool ct;                 // 器件是否构建好了
    int level;               // 器件层级
    int output;              // 器件输出
    vector<string> input_str;// 器件输入的器件/输入
    vector<int> input;       // 器件此次的输入
    vector<bool> inputDecFlag;// 器件在对应位置上的输入是否构建好了

    device (){
        level = -1;
        ct = false;
    }

    compute() {
        int result = input[0];
        if (type == "NOT") {
            result = !result;
        }
        else if (type == "AND") {
            for (int i = 1; i < input.size(); ++i) {
                result &= input[i];
            }
        }
        else if (type == "OR") {
            for (int i = 1; i < input.size(); ++i) {
                result |= input[i];
            }
        }
        else if (type == "XOR") {
            for (int i = 1; i < input.size(); ++i) {
                result ^= input[i];
            }
        }
        else if (type == "NAND") {
            for (int i = 1; i < input.size(); ++i) {
                result &= input[i];
            }
            result = !result;
        }
        else {
            for (int i = 1; i < input.size(); ++i) {
                result |= input[i];
            }
            result = !result;
        }

        output = result;
    }
};

int strToNum(string input_str) {
    /*
    int result = 0;
    for (int i = 1; i < input_str.size(); ++i) {
        result = result * 10 + (input_str[i] - '0');
    }

    return result;
    */
    int result;
    string str = input_str.substr(1); //截取I/O后面的数字字符串
    stringstream ss;
    ss << str;
    ss >> result;
    return result;
}

bool cmp(device d1, device d2) {
    return d1.level < d2.level;  // <
}

int main() {
    int Q;
    cin>>Q;

    for (int q = 0; q < Q; ++q) {
        int M, N;
        cin>>M>>N;

        // 器件
        device dce[N+2];

        // 输入器件信息
        for (int i = 1; i <= N; ++i) {
            string FUNC;
            int k;
            cin>>FUNC>>k;

            dce[i].type = FUNC;
            dce[i].id = i;
            for (int j = 0; j < k; ++j) {
                string inInfo;
                cin>>inInfo;
                dce[i].inputDecFlag.emplace_back(false);
                dce[i].input_str.emplace_back(inInfo);

            }
        }

        int S;
        cin>>S;

        // 输入
        //vector<vector<int> > input;
        int input[S][M];
        //vector<vector<int> > outputDce;
        vector<int> outputDce[S];

        // 输入每次输入的信息
        for (int i = 0; i < S; ++i) {
            //input.emplace_back(vector<int>());
            for (int j = 0; j < M; ++j) {
                int tmp;
                cin>>tmp;
                //input[i].emplace_back(tmp);
                input[i][j] = tmp;
            }
        }
        // 输入每次输出的要求
        for (int i = 0; i < S; ++i) {
            int num;
            cin>>num;
            //outputDce.emplace_back(vector<int>());
            for (int j = 0; j < num; ++j) {
                int tmp;
                cin>>tmp;
                outputDce[i].emplace_back(tmp);
            }
        }

        //
        bool loop = false;

        // 构建设备之间的联系
        while (1) {
            int preState[N + 1];
            // 保留前一次的层级
            for (int i = 1; i <= N; ++i) {
                preState[i] = dce[i].level;
            }
            // 更新层级
            int cont = 0; // 记录是否有更新
            for (int i = 1; i <= N; ++i) {
                // 当前设备未构建完成
                if ( !dce[i].ct) {
                    ++cont;
                    // 对每个输入设备
                    for (int j = 0; j < dce[i].input_str.size(); ++j) {
                        // 当前设备未入册
                        if ( !dce[i].inputDecFlag[j]) {
                            string str = dce[i].input_str[j];
                            int preNum = strToNum(str);
                            // 直接接输入
                            if (str[0] == 'I') {
                                dce[i].inputDecFlag[j] = true;
                                //dce[preNum].level = max(0, dce[preNum].level);
                                dce[i].level = max(0, dce[i].level);
                            }
                            // 从其他设备接入
                            else {
                                // 如果这个设备的输入是另一个设备的输出， 且该设备已经构建好了
                                if (dce[preNum].ct) {
                                    dce[i].inputDecFlag[j] = true;
                                    //dce[preNum].level = max(dce[preNum].level + 1, dce[preNum].level);
                                    dce[i].level = max(dce[preNum].level + 1, dce[i].level);
                                }
                            }
                        }
                    }

                    // 如果当前设备输入都已入册
                    for (int j = 0; j < dce[i].input_str.size(); ++j) {
                        if (dce[i].inputDecFlag[j] == false) {  // 未全部入册
                            break;
                        }
                        if (j == dce[i].input_str.size() - 1) {  // 全入册了
                            dce[i].ct = true;
                        }
                    }
                }
            }
            // 没有更新了， 说明当前没有环路， 且设备间的关系构建完成
            if (cont == 0) {
                break;
            }
            // 判断是否有环路
            for (int i = 1; i <= N; ++i) {
                if (preState[i] != dce[i].level) {
                    break;
                }
                if (i == N) {
                    loop = true;
                }
            }
            // 有环路
            if (loop) {
                break;
            }
        }

        // 判断是否有环路
        if (loop) {
            cout<<"LOOP"<<endl;
        }
        else {
            // 没有环路， 对于每一次的输入 和 指定的输出 来说， 需要进行如下操作
            sort(dce, dce+N, cmp) ;  // ！！！很重要！！！， 根据level来排序才能不用每次都考虑当前设备前一个设备的输出啦

            for (int i = 0; i < S; ++i) {
                map<int, int> id2output;
                // 计算
                // 对每个设备
                for (int j = 1; j <= N; ++j) {
                    for (int sIndex = 0; sIndex < dce[j].input_str.size(); ++sIndex) {
                        string str = dce[j].input_str[sIndex];
                        if (str[0] == 'I') {
                            dce[j].input.emplace_back(input[i][strToNum(str) - 1]);  // - 1
                        }
                        else {
                            dce[j].input.emplace_back(dce[strToNum(str)].output);
                        }
                    }
                    // 计算
                    dce[j].compute();
                    id2output[j] = dce[j].output;
                }

                // 输出
                for (int j = 0; j < outputDce[i].size(); ++j) {
                    cout<<id2output[outputDce[i][j]]<<" ";
                }
                cout<<endl;

                id2output.clear();
                for (int j = 1; j <= N; ++j) {
                    dce[j].input.clear();
                }
            }
        }
    }


    return 0;
}

层级： 60分， 运行超时， ！细节！

照着大佬的代码，改了很多地方。几乎除了变量名外，其他都变了。
我猜主要原因是 sort（）那里，我写的是+N， 不是 +N+2。

#include <iostream>
#include <string.h>
#include <vector>
#include <map>
#include <algorithm>
#include <sstream>

using namespace std;

struct device {
    int id;                  // 器件编号
    string type;             // 器件类型
    bool ct;                 // 器件是否构建好了
    int level;               // 器件层级
    int output;              // 器件输出
    vector<string> input_str;// 器件输入的器件/输入
    vector<int> input;       // 器件此次的输入
    vector<bool> inputDecFlag;// 器件在对应位置上的输入是否构建好了

    device (){
        level = -1;
        ct = false;
    }

    compute()
    {
        int result = input[0];
        if(type=="NOT") result=!input[0];
		else if(type=="AND")
        {
            for(int i=1;i<input.size();i++)
            {
                result &= input[i];
            }
        }
		else if(type=="OR")
        {
            for(int i=1;i<input.size();i++)
            {
                result |= input[i];
            }
        }
		else if(type=="XOR")
        {
            for(int i=1;i<input.size();i++)
            {
                result ^= input[i];
            }
        }
        else if(type=="NAND")
        {
            for(int i=1;i<input.size();i++)
            {
                result &= input[i];
            }
            result = !result;
        }
        else
        {
            for(int i=1;i<input.size();i++)
            {
                result |= input[i];
            }
            result = !result;
        }
        output = result;
    }
};

int strToNum(string s) {
    int result;
    string str = s.substr(1); //截取I/O后面的数字字符串
    stringstream ss;
    ss << str;
    ss >> result;
    return result;
}

bool cmp(device d1, device d2) {
    return d1.level < d2.level;  // <
}

int main() {
    int Q;
    cin>>Q;

    for (int q = 0; q < Q; ++q) {
        int M, N;
        cin>>M>>N;

        // 器件
        device dce[N];

        // 输入器件信息
        for (int i = 0; i < N; ++i) {
            string FUNC;
            int k;
            cin>>FUNC>>k;

            dce[i].type = FUNC;
            dce[i].id = i +1;
            for (int j = 0; j < k; ++j) {
                string inInfo;
                cin>>inInfo;
                dce[i].inputDecFlag.emplace_back(false);
                dce[i].input_str.emplace_back(inInfo);

            }
        }

        int S;
        cin>>S;

        // 输入
        //vector<vector<int> > input;
        int input[S][M];
        //vector<vector<int> > outputDce;
        vector<int> outputDce[S];

        // 输入每次输入的信息
        for (int i = 0; i < S; ++i) {
            //input.emplace_back(vector<int>());
            for (int j = 0; j < M; ++j) {
                //int tmp;
                cin>>input[i][j];
                //input[i].emplace_back(tmp);
                //input[i][j] = tmp;
            }
        }
        // 输入每次输出的要求
        for (int i = 0; i < S; ++i) {
            int num;
            cin>>num;
            //outputDce.emplace_back(vector<int>());
            for (int j = 0; j < num; ++j) {
                int tmp;
                cin>>tmp;
                outputDce[i].emplace_back(tmp);
            }
        }

        //
        bool loop = false;
        int cont = 0; // 记录是否有更新
        int preState[N + 1];
        // 构建设备之间的联系
        while (1) {
            cont = 0;
            // 保留前一次的层级
            for (int i = 0; i < N; ++i) {
                preState[i] = dce[i].level;
            }
            // 更新层级

            for (int i = 0; i < N; ++i) {
                // 当前设备未构建完成
                if ( !dce[i].ct) {
                    ++cont;
                    // 对每个输入设备
                    for (int j = 0; j < dce[i].input_str.size(); ++j) {
                        // 当前设备未入册
                        int run_level;
                        if ( !dce[i].inputDecFlag[j]) {
                            string str = dce[i].input_str[j];
                            int preNum = strToNum(str);

                            // 直接接输入
                            if (str[0] == 'I') {
                                run_level = 0;
                                dce[i].inputDecFlag[j] = true;
                                //dce[preNum].level = max(0, dce[preNum].level);
                                //dce[i].level = max(0, dce[i].level);
                            }
                            // 从其他设备接入
                            else if (str[0] == 'O') {
                                // 如果这个设备的输入是另一个设备的输出， 且该设备已经构建好了
                                if (dce[preNum - 1].ct) {
                                    dce[i].inputDecFlag[j] = true;
                                    //dce[preNum].level = max(dce[preNum].level + 1, dce[preNum].level);
                                    //dce[i].level = max(dce[preNum].level + 1, dce[i].level);
                                    run_level = dce[preNum - 1].level + 1;
                                }
                            }
                            if (run_level > dce[i].level) {
                                dce[i].level = run_level;
                            }
                        }
                    }

                    // 如果当前设备输入都已入册
                    for (int j = 0; j < dce[i].inputDecFlag.size(); ++j) {
                        if ( !dce[i].inputDecFlag[j]) {  // 未全部入册
                            break;
                        }
                        if (j == dce[i].input_str.size() - 1) {  // 全入册了
                            dce[i].ct = true;
                        }
                    }
                }
            }
            // 没有更新了， 说明当前没有环路， 且设备间的关系构建完成
            if (cont == 0) {
                break;
            }
            int same_num = 0;
            for (int i = 1; i <= N; ++i) {
                if (preState[i] == dce[i].level) {
                    ++same_num;
                }
            }
            // 有环路
            if (same_num == N) {
                loop = true;
                break;
            }
        }

        // 判断是否有环路
        if (loop) {
            cout<<"LOOP"<<endl;
        }
        else {
            // 没有环路， 对于每一次的输入 和 指定的输出 来说， 需要进行如下操作
            sort(dce, dce+N, cmp) ;  // ！！！很重要！！！， 根据level来排序才能不用每次都考虑当前设备前一个设备的输出啦

            for (int i = 0; i < S; ++i) {
                map<int, int> id2output;
                // 计算
                // 对每个设备
                for (int j = 0; j < N; ++j) {
                    for (int sIndex = 0; sIndex < dce[j].input_str.size(); ++sIndex) {
                        string str = dce[j].input_str[sIndex];
                        if (str[0] == 'I') {
                            dce[j].input.emplace_back(input[i][strToNum(str) - 1]);  // - 1
                        }
                        else {
                            //dce[j].input.emplace_back(dce[strToNum(str)].output);
                            dce[j].input.emplace_back(id2output[strToNum(str)]);
                        }
                    }
                    // 计算
                    dce[j].compute();
                    id2output[dce[j].id] = dce[j].output;
                }

                // 输出
                for (int j = 0; j < outputDce[i].size(); ++j) {
                    cout<<id2output[outputDce[i][j]]<<" ";
                }
                cout<<endl;

                id2output.clear();
                for (int j = 0; j < N; ++j) {
                    dce[j].input.clear();
                }
            }
        }
    }


    return 0;
}

层级：终于100了

改动了一个地方，将i=1->N 改成了 i=0->N-1.

#include <iostream>
#include <string.h>
#include <vector>
#include <map>
#include <algorithm>
#include <sstream>

using namespace std;

struct device {
    int id;                  // 器件编号
    string type;             // 器件类型
    bool ct;                 // 器件是否构建好了
    int level;               // 器件层级
    int output;              // 器件输出
    vector<string> input_str;// 器件输入的器件/输入
    vector<int> input;       // 器件此次的输入
    vector<bool> inputDecFlag;// 器件在对应位置上的输入是否构建好了

    device (){
        level = -1;
        ct = false;
    }

    compute()
    {
        int result = input[0];
        if(type=="NOT") result=!input[0];
		else if(type=="AND")
        {
            for(int i=1;i<input.size();i++)
            {
                result &= input[i];
            }
        }
		else if(type=="OR")
        {
            for(int i=1;i<input.size();i++)
            {
                result |= input[i];
            }
        }
		else if(type=="XOR")
        {
            for(int i=1;i<input.size();i++)
            {
                result ^= input[i];
            }
        }
        else if(type=="NAND")
        {
            for(int i=1;i<input.size();i++)
            {
                result &= input[i];
            }
            result = !result;
        }
        else
        {
            for(int i=1;i<input.size();i++)
            {
                result |= input[i];
            }
            result = !result;
        }
        output = result;
    }
};

int strToNum(string s) {
    int result;
    string str = s.substr(1); //截取I/O后面的数字字符串
    stringstream ss;
    ss << str;
    ss >> result;
    return result;
}

bool cmp(device d1, device d2) {
    return d1.level < d2.level;  // <
}

int main() {
    int Q;
    cin>>Q;

    for (int q = 0; q < Q; ++q) {
        int M, N;
        cin>>M>>N;

        // 器件
        device dce[N];

        // 输入器件信息
        for (int i = 0; i < N; ++i) {
            string FUNC;
            int k;
            cin>>FUNC>>k;

            dce[i].type = FUNC;
            dce[i].id = i +1;
            for (int j = 0; j < k; ++j) {
                string inInfo;
                cin>>inInfo;
                dce[i].inputDecFlag.emplace_back(false);
                dce[i].input_str.emplace_back(inInfo);

            }
        }

        int S;
        cin>>S;

        // 输入
        //vector<vector<int> > input;
        int input[S][M];
        //vector<vector<int> > outputDce;
        vector<int> outputDce[S];

        // 输入每次输入的信息
        for (int i = 0; i < S; ++i) {
            //input.emplace_back(vector<int>());
            for (int j = 0; j < M; ++j) {
                //int tmp;
                cin>>input[i][j];
                //input[i].emplace_back(tmp);
                //input[i][j] = tmp;
            }
        }
        // 输入每次输出的要求
        for (int i = 0; i < S; ++i) {
            int num;
            cin>>num;
            //outputDce.emplace_back(vector<int>());
            for (int j = 0; j < num; ++j) {
                int tmp;
                cin>>tmp;
                outputDce[i].emplace_back(tmp);
            }
        }

        //
        bool loop = false;
        int cont = 0; // 记录是否有更新
        int preState[N];
        // 构建设备之间的联系
        while (1) {
            cont = 0;
            // 保留前一次的层级
            for (int i = 0; i < N; ++i) {
                preState[i] = dce[i].level;
            }
            // 更新层级

            for (int i = 0; i < N; ++i) {
                // 当前设备未构建完成
                if ( !dce[i].ct) {
                    ++cont;
                    // 对每个输入设备
                    for (int j = 0; j < dce[i].input_str.size(); ++j) {
                        // 当前设备未入册
                        int run_level;
                        if ( !dce[i].inputDecFlag[j]) {
                            string str = dce[i].input_str[j];
                            int preNum = strToNum(str);

                            // 直接接输入
                            if (str[0] == 'I') {
                                run_level = 0;
                                dce[i].inputDecFlag[j] = true;
                                //dce[preNum].level = max(0, dce[preNum].level);
                                //dce[i].level = max(0, dce[i].level);
                            }
                            // 从其他设备接入
                            else if (str[0] == 'O') {
                                // 如果这个设备的输入是另一个设备的输出， 且该设备已经构建好了
                                if (dce[preNum - 1].ct) {
                                    dce[i].inputDecFlag[j] = true;
                                    //dce[preNum].level = max(dce[preNum].level + 1, dce[preNum].level);
                                    //dce[i].level = max(dce[preNum].level + 1, dce[i].level);
                                    run_level = dce[preNum - 1].level + 1;
                                }
                            }
                            if (run_level > dce[i].level) {
                                dce[i].level = run_level;
                            }
                        }
                    }

                    // 如果当前设备输入都已入册
                    for (int j = 0; j < dce[i].inputDecFlag.size(); ++j) {
                        if ( !dce[i].inputDecFlag[j]) {  // 未全部入册
                            break;
                        }
                        if (j == dce[i].input_str.size() - 1) {  // 全入册了
                            dce[i].ct = true;
                        }
                    }
                }
            }
            // 没有更新了， 说明当前没有环路， 且设备间的关系构建完成
            if (cont == 0) {
                break;
            }
            int same_num = 0;
            for (int i = 0; i < N; ++i) {  /* enmmm,这里  i = 0->N-1 */
                if (preState[i] == dce[i].level) {
                    ++same_num;
                }
            }
            // 有环路
            if (same_num == N) {
                loop = true;
                break;
            }
        }

        // 判断是否有环路
        if (loop) {
            cout<<"LOOP"<<endl;
        }
        else {
            // 没有环路， 对于每一次的输入 和 指定的输出 来说， 需要进行如下操作
            sort(dce, dce+N, cmp) ;  // ！！！很重要！！！， 根据level来排序才能不用每次都考虑当前设备前一个设备的输出啦

            for (int i = 0; i < S; ++i) {
                map<int, int> id2output;
                // 计算
                // 对每个设备
                for (int j = 0; j < N; ++j) {
                    for (int sIndex = 0; sIndex < dce[j].input_str.size(); ++sIndex) {
                        string str = dce[j].input_str[sIndex];
                        if (str[0] == 'I') {
                            dce[j].input.emplace_back(input[i][strToNum(str) - 1]);  // - 1
                        }
                        else {
                            //dce[j].input.emplace_back(dce[strToNum(str)].output);
                            dce[j].input.emplace_back(id2output[strToNum(str)]);
                        }
                    }
                    // 计算
                    dce[j].compute();
                    id2output[dce[j].id] = dce[j].output;
                }

                // 输出
                for (int j = 0; j < outputDce[i].size(); ++j) {
                    cout<<id2output[outputDce[i][j]]<<" ";
                }
                cout<<endl;

                id2output.clear();
                for (int j = 0; j < N; ++j) {
                    dce[j].input.clear();
                }
            }
        }
    }


    return 0;
}

拓扑排序（100）

字符串转数字

#include <iostream>
#include <algorithm>
string s = "A123";
// 需要加（char *）， 避免出错。 因为s指向的是常量， 常量不能直接赋值给char*类型。 看解释： https://blog.csdn.net/ku360517703/article/details/8180818
char *cs = (char*)s.substr(1).c_str();  // char *cs = (char*)s.substr(1, s.length() - 1).c_str();
int num_1 = atoi(cs);  // 123
int num_2 = atoi(s.substr(1, s.length() - 1).c_str()) ;  // 123

虽然看了大佬代码好几遍。但每次自己尝试去写，总会有些疑惑的地方，于是看一遍，重写一遍。第三遍重写终于把完整的代码和思路写完啦，并且一次就写出来了满分~ 不得不说大佬写的博客真的让人受益匪浅。

学到的知识点：
1、图、邻接表的构建。
2、有向无环图的检测与广搜  ————— ！ 入度很重要 ！。
3、mencpy()、memset()、fill、atoi() 的使用

自己再随意记录记录：
1、 注意全局定义时的MAXN 和 MAXM的使用
2、弄清楚tab的含义， tab[i][j]是 i 指向 j， 那 i 就有可能是 输入、也可能是器件， j 只可能是器件。
3、注意各下标的含义， 注意有没有包含输入。 同时，最好是在输入或者说初始化就给弄好，不要搞到要计算结果的时候再去+1、-1的，这样很容易弄混淆、弄糊涂。
4、全局变量要记得清理清理， clear clear。
5、多多练题， 加油~

贴上代码：

#include <iostream>
#include <vector>
#include <queue>  // queue
#include <string.h>  // memcpy ...
#include <algorithm>  // atoi、 fill

using namespace std;

// 常量
const int MAXK = 5;
const int MAXN = 501;
const int MAXM = 2501;  // k * N
const int MAXS = 100001;

// 器件
vector<int> tab[MAXN + MAXM]; // 邻接表（包含输入和器件） dce[i][j]: i->j
string type[MAXN];            // 每个器件的类型
int InD[MAXN + MAXM];         // 每个器件和输入的入度

// 输入
vector<vector<int> > input;     // 输入
vector<vector<int> > outputDev;  // 每个输入要求输出的器件编号

// 输出
int output[MAXN + MAXM];  // 输入和器件的结果


// 判断邻接表是不是有向无环图
bool topologicalSort(int  N, int M) {
    int curInD[MAXN + MAXM];
    memcpy(curInD, InD, sizeof(InD));

    queue<int> que;  // 记录入度为0
    for (int i = 0; i < N + M; ++i) {
        if (curInD[i] == 0) {
            que.push(i);
        }
    }

    int num = 0;
    while ( !que.empty()) {
        int cur = que.front();
        que.pop();
        ++num;

        for (int i = 0; i < tab[cur].size(); ++i) {
            int nex = tab[cur][i];

            if (curInD[nex] != 0) {
                --curInD[nex];
                if (curInD[nex] == 0) {
                    que.push(nex);
                }
            }
        }
    }

    if (num == N + M) {
        return false;
    }
    else {
        return true;
    }
}

void compute(int N, int M) {
    bool ini[MAXN] = {false};

    int curInD[MAXN + MAXM];
    memcpy(curInD, InD, sizeof(InD));

    queue<int> que;  // 记录入度为0
    for (int i = 0; i < N + M; ++i) {
        if (curInD[i] == 0) {
            que.push(i);
        }
    }

    while ( !que.empty()) {
        int cur = que.front();
        que.pop();

        for (int i = 0; i < tab[cur].size(); ++i) {
            int nex = tab[cur][i];

            if (curInD[nex] != 0) {
                --curInD[nex];

                // 器件未被初始化过， 没遇到过输入
                if (ini[nex - M] == false) {
                    output[nex] = output[cur];
                    ini[nex - M] = true;
                    if (type[nex - M] == "NOT") {
                        output[nex] = !output[nex];
                    }
                }
                // 遇见过输入
                else {
                    if (type[nex - M] == "AND" || type[nex - M] == "NAND") {
                        output[nex] = output[nex] & output[cur];
                    }
                    else if (type[nex - M] == "OR" || type[nex - M] == "NOR") {
                        output[nex] = output[nex] | output[cur];
                    }
                    else if (type[nex - M] == "XOR") {
                        output[nex] = output[nex] ^ output[cur];
                    }
                }

                if (curInD[nex] == 0) {
                    que.push(nex);
                    if (type[nex - M] == "NOR" || type[nex - M] == "NAND") {
                        output[nex] = !output[nex];
                    }
                }
            }
        }
    }
}

int main() {
    int Q;
    cin>>Q;

    for (int q = 0; q < Q; ++q) {
        int M, N;
        cin>>M>>N;

        fill(InD, InD + MAXM + MAXN, 0);  // 初始化入度  // 清理

        // 输入器件信息， 构建邻接表
        for (int n = 0; n < N; ++n) {
            cin>>type[n];
            int K;  // 每个器件的输入数
            cin>>K;

            InD[n + M] = K;  // 记录器件入度数
            for (int k = 0; k < K; ++k) {
                string t;
                cin>>t;

                int pre = atoi(t.substr(1).c_str()) - 1;  // -1, start from 0
                if (t[0] == 'O') {             // 器件编号 （-1+m)
                    pre += M;
                }
                tab[pre].emplace_back(n + M);  // 构建邻接表
            }
        }

        // S个输入
        int S;
        cin>>S;
        // S个输入的输入
        for (int s = 0; s < S; ++s) {
            input.emplace_back();
            for (int m = 0; m < M; ++m) {
                int cur;
                cin>>cur;
                input[s].emplace_back(cur);
            }
        }
        // S个输入对应要求输出的器件的编号
        for (int s = 0; s < S; ++s) {
            outputDev.emplace_back();
            int num;
            cin>>num;
            for (int n = 0; n < num; ++n) {
                int cur;
                cin>>cur;
                cur += (M - 1);
                outputDev[s].emplace_back(cur);
            }
        }

        // 成环
        if (topologicalSort(N, M)) {
            cout<<"LOOP"<<endl;
        }
        // 不成环
        else {
            for (int s = 0; s < S; ++s) {
                // 初始化
                fill(output, output + MAXN + MAXM, 0);  // 清理
                for (int i = 0; i < M; ++i) {
                    output[i] = input[s][i];
                }

                compute(N, M);

                // 输出
                for (int i = 0; i < outputDev[s].size(); ++i) {
                    cout<<output[outputDev[s][i]]<<" ";
                }
                cout<<endl;
            }
        }

        // 清理一下
        input.clear();
        outputDev.clear();
        for (int i = 0; i < MAXN + MAXM; i++) {
            tab[i].clear();
        }
        /*
        for (int i = 0; i < MAXN; ++i) {
            type[i] = "";
        }
        */
    }

    return 0;
}
猫娜Lisa
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【CSP】202009-3点亮数字人生(拓扑排序)
weixin_45720246的博客
12-19 397
本题并不难，主要在于将电路连接图抽象为有向图，然后进行简单拓扑排序即可，下文给出代码在已在几个点给出注释 /* * @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 2020年09月 第三题：点亮数字人生（dfs + 判环）
一只谜谜怪的博客
10-02 2871
题目背景 土豪大学的计算机系开了一门数字逻辑电路课，第一个实验叫做“点亮数字人生”，要用最基础的逻辑元件组装出实际可用的电路。时间已经是深夜了，尽管实验箱上密密麻麻的连线已经拆装了好几遍，小君同学却依旧没能让她的电路正常工作。你能帮助她模拟出电路的功能，成功点亮她的数字人生吗？ 问题描述 本题中，你需要实现一个简单的数字逻辑电路模拟器。如果你已经有了此方面的基础，可以直接跳过本节。在阅读时，也可以参照前两个样例的图示和解释，这有助于你更好地理解数字逻辑电路的工作原理。 数字逻辑电路是用来传输数字信号（也就是
CCF-CSP 202009-3 点亮数字人生 拓扑排序+模拟
M_theory004的博客
10-11 578
#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')) ...
2020-09-3 CCF CSP 点亮数字人生(拓扑排序 判环)
lizhenhao
03-02 449
经典急了急了。。 第三题判断环的存在有一万种方式，拓扑排序，甚至撸上去一个tarjan都行，非自己图快意淫出一个不存在的递归算法然后把心态调崩了。。导致只拿了五十分。 100分： #include <bits/stdc++.h> using namespace std; const int N = 1e5+10; vector<int> iput[N], oput[N]; string op[N]; int du[N],bdu[N]; int h[N], tot, n, m;
CCF-CSP-202009-3：点亮数字人生（题解）
Fng的博客
04-11 1315
土豪大学的计算机系开了一门数字逻辑电路课，第一个实验叫做“点亮数字人生”，要用最基础的逻辑元件组装出实际可用的电路。时间已经是深夜了，尽管实验箱上密密麻麻的连线已经拆装了好几遍，小君同学却依旧没能让她的电路正常工作。你能帮助她模拟出电路的功能，成功点亮她的数字人生吗？
CCF-CSP-and-PAT-solution:CCF CSP和PAT考试题解（使用C++14语法）
04-17
CCF CSP 考试和 PAT 顶级甲级乙级考试题解本仓库是书籍《算法详解（C++11 语言描述）》（预计 2021 年 5 月左右出版）的配套仓库，主要负责更新 CCF CSP 和 PAT 顶级甲级乙级题解代码。由于 CCF CSP 和 PAT 考试都已...
2021 CSP-J1 junior-C++ 初赛　第1轮　真题　.pdf
09-20
本文档是对 2021 CSP-J1 junior-C++ 初赛第 1 轮真题的详细解析，以帮助读者更好地理解题目内容和解题思路。 一、单项选择题 1. 不属于面向对象程序设计语言的是（ ）。 答案：D. C。面向对象程序设计语言主要有 ...
2022 CSP-J1 CSP-S1 初赛 资料集（2022.07.08).pdf
07-08
知识点 3：CSP-J1 CSP-S1 相关书籍 本资源提供了 CSP-J1 CSP-S1 初赛相关书籍的推荐，旨在帮助选手更好地备战考试。 知识点 4：CSP-J1 CSP-S1 培训计划及学习要点 本资源提供了 2022 年暑期及 9 月份 CSP-J1 CSP-...
0、信息学奥赛(CSP-J CSP-S NOI)相关书籍汇总--2021-04-24(C++版)D.pdf
04-24
信息学奥赛（CSP-J/CSP-S/NOIP）是针对中学生的计算机编程竞赛，旨在激发学生对计算机科学的兴趣，培养编程和解决问题的能力。CSP-J/S是CSP（China Software Professional Contest）的青少年版，NOIP则是全国青少年...
【CSP】点亮数字人生（202009）
Danger的博客
10-17 2080
点亮数字人生（202009）（40）
第 20 次 CSP认证 202009-3 点亮数字人生代码
qq_44103902的博客
09-15 682
题目 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;
CSP202009-3 点亮数字人生
qq_43381135的博客
01-22 577
CSP202009-3 点亮数字人生题目 题目
CCF 202009-3点亮数字人生 （100分）
Henimal00的博客
09-29 2359
（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
CSP 202009-3 点亮数字人生
最新发布
weixin_44340652的博客
09-06 378
谁来点亮鼠鼠的人生啊，最近属于是卷也卷不动，躺也躺不平。emmm，代码太长啦，及其不优雅。通过拓扑排序判断有向环学到了。一个bug调了1个小时，乐。
CCF CSP 点亮数字人生（100分）
weixin_44647458的博客
04-09 421
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;
点亮数字人生（思路+代码）
Barry的博客
10-17 901
思路： 抽象成图的问题 定义邻接表数据结构并初始化 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-点亮数字人生（附通过代码，思路，测试用例）
m0_56522574的博客
11-05 536
效果 一：题目描述 二：思路 1.每个逻辑门抽象成一个类，如下： 2.题目本质可以抽象成图，考虑怎么简化图首先逻辑门可以抽象成节点，用编号1-n表示，建图的时候可以先不考虑逻辑门功能（先存到一个数组中即可）。在拓扑排序时，再考虑逻辑门功能实现。于是，一个电路图就简单的简化成了一张有向图。如下图所示 3.判环过程可以在简化的图中进行。可以用spfa或者拓扑排序判环 4.由于逻辑门的信号传输是有顺序的，可用拓扑排序...
CSP 点亮数字人生（原创代码100分)
Danger的博客
10-17 2693
CSP 点亮数字人生 202009（满分ac）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值