点亮数字人生( 202009-3/CCF)———附带思路和完整代码（邻接表、邻接矩阵）

最新推荐文章于 2021-12-11 09:41:34 发布
最新推荐文章于 2021-12-11 09:41:34 发布
阅读量1.8k 收藏 21
点赞数 18
分类专栏： # CCF # 图 文章标签： 点亮数字人生 ccf 图 拓扑排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33375598/article/details/108914796
版权
CCF 同时被 2 个专栏收录
31 篇文章 3 订阅
订阅专栏
图
11 篇文章 0 订阅
订阅专栏
本文介绍了如何使用邻接表和邻接矩阵来模拟数字电路，包括图的构建、拓扑排序、计算逻辑门的值。通过邻接表和邻接矩阵实现拓扑排序判断电路是否有环，并计算电路中各组件的值。同时提供了测试数据和代码实现，涉及图的遍历、逻辑运算（与、或、非、异或）以及环的检测。
摘要由CSDN通过智能技术生成

文章目录

0 效果

邻接表：
在这里插入图片描述

邻接矩阵：
在这里插入图片描述
空间复杂度：邻接表比邻接矩阵少了接近1/4的大小。

难点：图的构建、拓扑排序、计算值、逻辑运算

1 题目

在这里插入图片描述

2 思路

数字电路抽象出来就是有向图，中间的过程是模拟作为边的入度的点使用位计算其值作为该点的权值，最后输入的结果就是类似于计算点权重。
步骤：

  • 1 构建图（邻接表、邻接矩阵），【构建的时候，就计算每个点的入度】；
  • 2 存储需要测试的输入、输出数据；
  • 3 使用拓扑排序来判断是否电路（有向图）是否成环；
  • 4 使用类似与拓扑排序的方法来从前向后依次计算每个元器件（点）的值。

注意点：

  • 每次计算下一个问题时，需要重新初始化变量；
  • 每次计算时，存储原始的入度，使用临时的入度来计算（因为计算时会多次用到入度）；
  • 使用std::copy(std::begin(inDegree), std::end(inDegree), std::begin(tempInDegree));复制数组时，ccf的编译器会爆编译错误；
  • 计算与非（NAND）和异或时（NOR）时，非操作只最后进行一次；
  • 注意换行、空格的输出；
  • 下文中，输入的点的编号用0～m-1来表示，元器见点的编号用m～m+n-1来表示

以下图为例，抽象为一个有向图：
在这里插入图片描述
抽象后的结果：
在这里插入图片描述

3 代码

邻接表：

#include<cstdio>
#include<vector>
#include<string>
#include<iostream>
#include<queue>
#include<string.h>
#include<algorithm>

//#include <bits/stdc++.h>
//using namespace std;

const int MAXV = 510;

typedef struct Node{
    int v;//边的终点
    Node(int _v):v(_v){}//初始化列表
}node;
std::vector<node> Adj[MAXV];//邻接表

//int G[MAXV][MAXV] = {0};//邻接矩阵
int w[MAXV];//边权重
//bool inq[MAXV] = {false};//是否访问过
bool initV[MAXV] = {false};//是否初始化过边
int inDegree[MAXV] = {0};//入度
//int outDegree[MAXV] = {0};//出度（未使用）
std::string type[MAXV]; //器件类型
std::vector<int> testInput[10010];//测试输入
std::vector<int> testOutput[10010];//测试输出

//拓扑排序，判断环
bool TopologicalSort(int n, int m){
    int num = 0;
    std::queue<int> q;
    int tempInDegree[MAXV];//临时存储入度
    memcpy(tempInDegree, inDegree, (m+n)* sizeof(int));//复制的字节数
    // std::copy(std::begin(inDegree), std::end(inDegree), std::begin(tempInDegree));
    for(int i = 0;i < n + m;i++){//将所有入度为0的顶点入队
        if(tempInDegree[i] == 0){
            q.push(i);
        }
    }
    while(!q.empty()){
        int u = q.front();
        q.pop();
        //邻接表
        for(int i = 0;i < Adj[u].size();i++){
            int v = Adj[u][i].v;
            tempInDegree[v]--;
            if(tempInDegree[v] == 0){
                q.push(v);
            }
        }
        //邻接矩阵
//        for(int i = 0; i < m + n;i++){
//            if(inq[i] == false && G[u][i] != 0){
//                tempInDegree[i]--;
//
//                if(tempInDegree[i] == 0){
//                    q.push(i);
//                    inq[i] = true;
//                }
//            }
//        }
        num++;
    }
    if(num == n + m) return true;
    else return false;
}
//计算值
void calculateValue(int n, int m){
    std::queue<int> q;
    int tempInDegree[MAXV];//临时存储入度
    memcpy(tempInDegree, inDegree, (m+n)* sizeof(int));//复制的字节数
    for(int i = 0;i < n + m;i++){//将所有入度为0的顶点入队
        if(tempInDegree[i] == 0){
            q.push(i);
        }
    }
    while(!q.empty()){
        int u = q.front();//起始点
        q.pop();

        //邻接表
        for(int i = 0;i < Adj[u].size();i++){
            int v = Adj[u][i].v;
            tempInDegree[v]--;

            if(initV[v] == false){//之前没有被访问过
                w[v] = w[u];//赋予初始值
                if(type[v] == "NOT"){//最多或者最少都只有一个输入
                    w[v] = (!w[v]);
                }
                initV[v] = true;
            }else{
                if(type[v] == "AND" || type[v] == "NAND"){
                    w[v] &= w[u];
                }else if(type[v] == "OR" || type[v] == "NOR"){
                    w[v] |= w[u];
                }else if(type[v] == "XOR"){
                    w[v] ^= w[u];
                }
            }
            if(tempInDegree[v] == 0){
                if(type[v] == "NAND" || type[v] == "NOR"){
                    w[v] = (!w[v]);
                }
                q.push(v);
            }
        }

//        for(int i = 0; i < m + n;i++){
//            if(inq[i] == false && G[u][i] != 0){
//                tempInDegree[i]--;
//
//                if(initV[i] == false){//之前没有被访问过
//                    w[i] = w[u];//赋予初始值
//                    if(type[i] == "NOT"){//最多或者最少都只有一个输入
//                        w[i] = (!w[i]);
//                    }
//                    initV[i] = true;
//                }else{
//                    if(type[i] == "AND" || type[i] == "NAND"){
//                        w[i] &= w[u];
//                    }else if(type[i] == "OR" || type[i] == "NOR"){
//                        w[i] |= w[u];
//                    }else if(type[i] == "XOR"){
//                        w[i] ^= w[u];
//                    }
//                }
//
//                if(tempInDegree[i] == 0){//入度为零，以它为终点的边数为0
//                    if(type[i] == "NAND" || type[i] == "NOR"){
//                        w[i] = (!w[i]);
//                    }
//                    q.push(i);
//                    inq[i] = true;
//                }
//            }
//        }


    }

}

int main(){
    int q, m, n;
    scanf("%d", &q);
    while(q--){//问题个数
        //初始化
        for(int i = 0;i < MAXV;i++){
            for(std::vector<node>::iterator j = Adj[i].begin();j != Adj[i].end();){
                j = Adj[i].erase(j);
            }
        }
        //std::fill(G[0], G[0] + MAXV*MAXV, 0);
        memset(inDegree, 0, sizeof(inDegree));
        //memset(outDegree, 0, sizeof(outDegree));
//        std::fill(inq, inq + MAXV, false);
        std::fill(initV, initV + MAXV, false);
        for(int i = 0;i < MAXV;i++){
            type[i].clear();
        }
        for(int i = 0;i < 10010;i++){
            for(std::vector<int>::iterator j = testInput[i].begin();j != testInput[i].end();){
                j = testInput[i].erase(j);
            }
        }
        for(int i = 0;i < 10010;i++){
            for(std::vector<int>::iterator j = testOutput[i].begin();j != testOutput[i].end();){
                j = testOutput[i].erase(j);
            }
        }

        scanf("%d%d", &m, &n);//输入个数，器件个数
        for(int num = m;num < n + m;num++){
            std::string FUNC;//器件描述
            int k;
            std::cin>>FUNC;
            type[num] = FUNC;

            scanf("%d", &k);
            for(int i = 0;i < k;i++){
                std::string L;
                std::cin>>L;
                int startPoint = std::atoi(L.substr(1, L.length() - 1).c_str()) - 1;//计算起始点编号
                if(L[0] != 'I'){//如果是输出点，则加上输入点的偏移
                    startPoint += m;
                }
                Adj[startPoint].push_back(node(num));//构造图
                //G[startPoint][num] = 1;
                // outDegree[startPoint]++;//计算出度
                inDegree[num]++;//计算入度
            }
        }

        int s;//运算次数
        scanf("%d", &s);
        for(int i = 0;i < s;i++){//输入数据
            for(int j = 0;j < m;j++){
                int input;
                scanf("%d", &input);
                testInput[i].push_back(input);
            }
        }

        for(int i = 0;i < s;i++){//输出数据
            int OutNum;
            scanf("%d", &OutNum);
            while(OutNum--){
                int output;
                scanf("%d", &output);
                output = output + m - 1;
                testOutput[i].push_back(output);
            }
        }

        if(TopologicalSort(n, m) == false){//有环
            printf("LOOP\n");
        }else{//无环
            for(int i = 0;i < s;i++){
                memset(w, 0, sizeof(w));
                //std::fill(inq, inq + MAXV, false);
                std::fill(initV, initV + MAXV, false);
                for(int j = 0;j < testInput[i].size();j++){//给初始输入点赋值
                    w[j] = testInput[i][j];
                }
                //计算点权
                calculateValue(n, m);

                for(int j = 0; j < testOutput[i].size();j++){
                    if(j != 0) printf(" ");
                    printf("%d", w[testOutput[i][j]]);
                }
                printf("\n");

            }
        }
    }//q

    return 0;
}
  • 邻接矩阵
#include<cstdio>
#include<vector>
#include<string>
#include<iostream>
#include<queue>
#include<string.h>
#include<algorithm>

//#include <bits/stdc++.h>
//using namespace std;

//typedef struct Node{
// int v;//边的终点
// Node(int _v):v(_v){}//初始化列表
//}node;
//std::vector<node> Adj[510];//邻接表
const int MAXV = 510;
int G[MAXV][MAXV] = {0};//邻接矩阵
int w[MAXV];//边权重
bool inq[MAXV] = {false};//是否访问过
bool initV[MAXV] = {false};//是否初始化过边
int inDegree[MAXV] = {0};//入度
int outDegree[MAXV] = {0};//出度（未使用）
std::string type[MAXV]; //器件类型
std::vector<int> testInput[10010];//测试输入
std::vector<int> testOutput[10010];//测试输出

//拓扑排序，判断环
bool TopologicalSort(int n, int m){
    int num = 0;
    std::queue<int> q;
    int tempInDegree[MAXV];//临时存储入度
    memcpy(tempInDegree, inDegree, (m+n)* sizeof(int));//复制的字节数
    // std::copy(std::begin(inDegree), std::end(inDegree), std::begin(tempInDegree));
    for(int i = 0;i < n + m;i++){//将所有入度为0的顶点入队
        if(tempInDegree[i] == 0){
            q.push(i);
        }
    }
    while(!q.empty()){
        int u = q.front();
        q.pop();

//        for(int i = 0;i < Adj[u].size();i++){
//           int v = Adj[u][i].v;
//           inDegree[v]--;
//           if(inDegree[v] == 0){
//              q.push(v);
//          }
//       }
        for(int i = 0; i < m + n;i++){
            if(inq[i] == false && G[u][i] != 0){
                tempInDegree[i]--;

                if(tempInDegree[i] == 0){
                    q.push(i);
                    inq[i] = true;
                }
            }
        }
        num++;
    }
    if(num == n + m) return true;
    else return false;
}
//计算值
void calculateValue(int n, int m){
    std::queue<int> q;
    int tempInDegree[MAXV];//临时存储入度
    memcpy(tempInDegree, inDegree, (m+n)* sizeof(int));//复制的字节数
    for(int i = 0;i < n + m;i++){//将所有入度为0的顶点入队
        if(tempInDegree[i] == 0){
            q.push(i);
        }
    }
    while(!q.empty()){
        int u = q.front();//起始点
        q.pop();

        for(int i = 0; i < m + n;i++){
            if(inq[i] == false && G[u][i] != 0){
                tempInDegree[i]--;

                if(initV[i] == false){//之前没有被访问过
                    w[i] = w[u];//赋予初始值
                    if(type[i] == "NOT"){//最多或者最少都只有一个输入
                        w[i] = (!w[i]);
                    }
                    initV[i] = true;
                }else{
                    if(type[i] == "AND" || type[i] == "NAND"){
                        w[i] &= w[u];
                    }else if(type[i] == "OR" || type[i] == "NOR"){
                        w[i] |= w[u];
                    }else if(type[i] == "XOR"){
                        w[i] ^= w[u];
                    }
                }

                if(tempInDegree[i] == 0){//入度为零，以它为终点的边数为0
                    if(type[i] == "NAND" || type[i] == "NOR"){
                        w[i] = (!w[i]);
                    }
                    q.push(i);
                    inq[i] = true;
                }
            }
        }
    }

}

int main(){
    int q, m, n;
    scanf("%d", &q);
    while(q--){//问题个数
        //初始化
        std::fill(G[0], G[0] + MAXV*MAXV, 0);
        memset(inDegree, 0, sizeof(inDegree));
        memset(outDegree, 0, sizeof(outDegree));
        std::fill(inq, inq + MAXV, false);
        std::fill(initV, initV + MAXV, false);
        for(int i = 0;i < MAXV;i++){
            type[i].clear();
        }
        for(int i = 0;i < 10010;i++){
            for(std::vector<int>::iterator j = testInput[i].begin();j != testInput[i].end();){
                j = testInput[i].erase(j);
            }
        }
        for(int i = 0;i < 10010;i++){
            for(std::vector<int>::iterator j = testOutput[i].begin();j != testOutput[i].end();){
                j = testOutput[i].erase(j);
            }
        }

        scanf("%d%d", &m, &n);//输入个数，器件个数
        for(int num = m;num < n + m;num++){
            std::string FUNC;//器件描述
            int k;
            std::cin>>FUNC;
            type[num] = FUNC;

            scanf("%d", &k);
            for(int i = 0;i < k;i++){
                std::string L;
                std::cin>>L;
                int startPoint = std::atoi(L.substr(1, L.length() - 1).c_str()) - 1;//计算起始点编号
                if(L[0] != 'I'){//如果是输出点，则加上输入点的偏移
                    startPoint += m;
                }
                //Adj[startPoint].push_back(node(num));//构造图
                G[startPoint][num] = 1;
                outDegree[startPoint]++;//计算出度
                inDegree[num]++;//计算入度
            }
        }

        int s;
        scanf("%d", &s);
        for(int i = 0;i < s;i++){//输入数据
            for(int j = 0;j < m;j++){
                int input;
                scanf("%d", &input);
                testInput[i].push_back(input);
            }
        }

        for(int i = 0;i < s;i++){//输出数据
            int OutNum;
            scanf("%d", &OutNum);
            while(OutNum--){
                int output;
                scanf("%d", &output);
                output = output + m - 1;
                testOutput[i].push_back(output);
            }
        }

        if(TopologicalSort(n, m) == false){
            printf("LOOP\n");
        }else{
            for(int i = 0;i < s;i++){
                memset(w, 0, sizeof(w));
                std::fill(inq, inq + 510, false);
                std::fill(initV, initV + MAXV, false);
                for(int j = 0;j < testInput[i].size();j++){
                    w[j] = testInput[i][j];
                }

                calculateValue(n, m);

                for(int j = 0; j < testOutput[i].size();j++){
                    if(j != 0) printf(" ");
                    printf("%d", w[testOutput[i][j]]);
                }
                printf("\n");

            }
        }
    }//q

    return 0;
}

4 测试数据

  • 1
    输入：
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 0
1 0
1 1
0 0
  • 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

输出：

LOOP
  • 3
    输入：
1
3 9
AND 3 I1 I2 I3
OR 3 I1 I2 I3
AND 2 I1 I2
AND 2 I1 I3
AND 2 I2 I3
OR 2 O1 O7
AND 2 O2 O8
NOT 1 O9
OR 3 O3 O4 O5
8
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1
2 6 9
2 6 9
2 6 9
2 6 9
2 6 9
2 6 9
2 6 9
2 6 9

输出：

0 0
1 0
1 0
0 1
1 0
0 1
0 1
1 1

在这里插入图片描述

  • 4
1
3 8
NAND 2 O2 O3
NAND 2 I1 O4
NAND 2 I2 O4
NAND 2 I1 I2
NAND 2 O6 O7
NAND 2 O1 O8
NAND 2 I3 O8
NAND 2 O1 I3
8
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1
1 5
1 5
1 5
1 5
1 5
1 5
1 5
1 5

输出：

0
1
1
0
1
0
0
1

在这里插入图片描述

  • 5
    输入：
1
1 2
AND 2 I1 O2
NOT 1 O1
2
0
1
0 0
2 1 2

输出：

LOOP

在这里插入图片描述
测试数据部分参考：https://blog.csdn.net/H_X_P_/article/details/108569908

繁星蓝雨
关注
专栏目录
CSP-J/S 报名全攻略（含考纲）
xinglun88的专栏
07-09 1739
CCF面向社会非专业人士推出CSP非专业级别软件能力认证。非专业级别能力认证CSP-J/S分两个级别，分别为CSP-J（入门级，Junior）和CSP-S（提高级，Senior），均涉及算法和编程。任何人都可以报名参加。
cloudflare入门之 /cdn-cgi/ 端点
蛐蛐的博客
09-26 1679
将域添加到 Cloudflare时，Cloudflare 会向该域添加一个/cdn-cgi/端点此端点由 Cloudflare 管理。它不能被修改或定制。
点亮数字人生（思路+代码）
Barry的博客
10-17 916
思路： 抽象成图的问题 定义邻接表数据结构并初始化 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行（
CSP 202009-3 点亮数字人生
旺崽的博客
03-19 2149
题目链接 建图 + DFS~ 题目比较简单，首先确定的是要建图的，那么对每个结点我们应该存哪些信息呢？我的结构体如下： kind，记录结点的元件种类 val，记录元件的输入信号 father，记录元件的父亲个数，这个我个人认为非常重要，因为在找环的时候，我们可以记录每个结点的遍历次数 cnt，若 cnt > father 证明图中一定出现了环 son，记录元件儿子结点的编号 这题因为所有元件的种类和编号固定，且编号不重复，所以可以直接用 map 对元件进行编号~ 至于求元件的值，直接用 DFS
ccf csp 2020年09月 第三题：点亮数字人生（dfs + 判环）
一只谜谜怪的博客
10-02 2896
题目背景 土豪大学的计算机系开了一门数字逻辑电路课，第一个实验叫做“点亮数字人生”，要用最基础的逻辑元件组装出实际可用的电路。时间已经是深夜了，尽管实验箱上密密麻麻的连线已经拆装了好几遍，小君同学却依旧没能让她的电路正常工作。你能帮助她模拟出电路的功能，成功点亮她的数字人生吗？ 问题描述 本题中，你需要实现一个简单的数字逻辑电路模拟器。如果你已经有了此方面的基础，可以直接跳过本节。在阅读时，也可以参照前两个样例的图示和解释，这有助于你更好地理解数字逻辑电路的工作原理。 数字逻辑电路是用来传输数字信号（也就是
CSP202009-3 点亮数字人生
qq_43381135的博客
01-22 595
CSP202009-3 点亮数字人生题目 题目
点亮数字人生
m0_43406494的博客
12-08 188
import re def NOT(a): return (a+1)%2 def AND(a,b,*c): ans=a and b if not c: return ans for i in c: if ans==0: return ans else: ans=ans and i return ans def OR(a,b,*c): a...
CCF 202009-3点亮数字人生 （100分）
Henimal00的博客
09-29 2379
（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
CCF CSP202009-3 点亮数字人生 (AC100分)(拓扑排序(判环)+链式前向星存图+模拟)
u011902923的博客
09-30 1219
在考场上很遗憾，由于平时练习，很缺少处理多组数据输入输出的经验，以及考场严重设备问题，这样一份白给的题出了很多很多错，其思维难度其实很低，但是并没有debug成功，很可惜，与当前一模一样的思路，可惜只拿了20分QAQ。 也非常令人感慨，无论是OI竞赛还是真正处理工程问题中，其实一些微小的错误就能让你为之停留很久，花费很多不必要的时间。 ①首先是多组数据输入时的初值(初始化是个好习惯) ②其次考场时的思路太杂乱、太跳脱了，并没有很好的顺着题意往下走，导致部分地方写的更复杂。 是人总是会犯错的，但有没有什么办法
信息学竞赛资料学校上课所用，关于CSP-S/NOIP/NOI
最新发布
01-03
CSP-S是CCF（中国计算机学会）设立的一项认证，主要考察选手的编程能力和算法应用水平。它分为两轮，每轮包含两个独立的题目，参赛者需要在规定时间内完成编程并提交代码。通过CSP-S认证，学生可以提升自己的编程...
【CSP】点亮数字人生（202009）
Danger的博客
10-17 2101
点亮数字人生（202009）（40）
ccf 202009-3 点亮数字人生（模拟+拓扑判环）
smilng的博客
01-17 294
题外： 这个题思路挺好想的，但是我命令序列的数组没开够卡了好久，， 所以这是小于kmax还是小于N呢，，我一直以为是kmax。。好吧我的锅 思路： 每个器件直接存在先后关系，比如1的输出是2的输入，那么必须先算1再算2，所以建个图找出拓扑序然后按着拓扑序计算各个值就可以了。整体来说没有什么坑点。 代码： #include <cstdio> #include<iostream> #include<algorithm> #include<cstring>
CCF CSP 点亮数字人生（100分）
weixin_44647458的博客
04-09 438
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;
CCF-CSP-202009-3：点亮数字人生（题解）
Fng的博客
04-11 1448
土豪大学的计算机系开了一门数字逻辑电路课，第一个实验叫做“点亮数字人生”，要用最基础的逻辑元件组装出实际可用的电路。时间已经是深夜了，尽管实验箱上密密麻麻的连线已经拆装了好几遍，小君同学却依旧没能让她的电路正常工作。你能帮助她模拟出电路的功能，成功点亮她的数字人生吗？
CCF CSP 202009-3 点亮数字人生
qq_37124218的博客
04-16 253
本题主要考察 有向图是否存在环路，记忆化搜索，状态压缩存储。 #include <bits/stdc++.h> //#include <iostream> //#include <queue> //#include <string> using namespace std; int Q, M, N, S; using ll = long long; // 状态压缩 ll input[10005][40]; short output[505]; bo
CCF-CSP 202009-3 点亮数字人生 拓扑排序+模拟
M_theory004的博客
10-11 584
#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')) ...
202009-3 点亮数字人生
佛系更新
12-11 959
202009-3 点亮数字人生，第二十次CCF计算机软件能力认证中的第三题，设计知识：拓扑排序以及模拟，是一道经典的大模拟题目，做大模拟题，能有效提高自己的码代码水平，建议反复练习本题
CCF CSP 202009-3 点亮数字人生-详细注释版
sum___mer的博客
04-08 451
CCF CSP 202009-3 点亮数字人生-详细注释版 #include <iostream> // 直接到拉到最下方 主函数 #include <cstring> #include <algorithm> #include <unordered_map> #include <unordered_set> #include <cmath> #include <map> #include <set> #inc
2020 CSP-J/S NOIP复赛题解及解析汇总
对于C题，虽然"表达式——只有思路缺AC代码"可能没有提供完整的解决方案，但它给出了关键的解题思路，这对于参赛者理解问题本质至关重要。 "CSP2020-S题解"则关注了更高级别组的题目，通常这些题目更具挑战性，需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

繁星蓝雨

如果觉得文章不错，可以请喝咖啡

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值