CCF-202009-3数字点亮人生Java50分题解

求助各路兄弟：我判断了环路，为什么还是只有50分😭

下面贴出代码（我就不多解释什么了，都在注释里面了）

package mock202009;

import java.util.*;

public class Main3 {
    public enum Func{NOT, AND, OR, XOR, NAND, NOR};

    public static class Meta{
        public Func type;
        public List<Integer> inputs;   // 来自外部的输入
        public List<Integer> receive; // 来自其他器件的输入
        public int totalInputNum;

        public List<Boolean> states;  // 某次输入后 所有输入端的状态，注意在下次运行的时候要清空
        public Boolean result = null;   // 器件输出结果，也要记得清空

        @Override
        public String toString() {
            return "Meta [type=" + type + ", inputs="
                    + inputs + ", recieve=" + receive + "] result = " + result;
        }

        public void calcuResult(){
            switch(type) {
                case NOT:
                    result = !states.get(0);
                    break;
                case OR:
                    result = states.get(0);
                    for(int i = 1; i < states.size(); i++) {
                        result |= states.get(i);
                    }
                    break;
                case XOR:
                    result = states.get(0);
                    for(int i = 1; i < states.size(); i++) {
                        result ^= states.get(i);
                    }
                    break;
                case AND:
                    result = states.get(0);
                    for(int i = 1; i < states.size(); i++) {
                        result &= states.get(i);
                    }
                    break;
                case NOR:
                    result = states.get(0);
                    for(int i = 1; i < states.size(); i++) {
                        result |= states.get(i);
                    }
                    result = !result;
                    break;
                case NAND:
                    result = states.get(0);
                    for(int i = 1; i < states.size(); i++) {
                        result &= states.get(i);
                    }
                    result = !result;
                    break;
            }
        }
    }

    public static void main(String[] args) {
//        testMeta();
        Scanner scanner = new Scanner(System.in);
        int Q = Integer.parseInt(scanner.nextLine()); // total electron road to solve

        while(Q > 0) {
            Q--;
            String[] elements = scanner.nextLine().split(" ");
            // M is the total input number            N is the total metas number
            int M = Integer.parseInt(elements[0]), N = Integer.parseInt(elements[1]);

            // 邻接矩阵
            boolean[][] graph = new boolean[N][N];
            int[] intoDegree = new int[N]; // 入度表

            List<Meta> metaList = new ArrayList<>();
            for(int i = 0; i < N;i++){
                elements = scanner.nextLine().split(" ");
                Meta meta = new Meta();
                Func type = null;
                // 判断器件类型
                switch(elements[0]) {
                    case "XOR":
                        type = Func.XOR;
                        break;
                    case "NOT":
                        type = Func.NOT;
                        break;
                    case "AND":
                        type = Func.AND;
                        break;
                    case "OR":
                        type = Func.OR;
                        break;
                    case "NAND":
                        type = Func.NAND;
                        break;
                    case "NOR":
                        type = Func.NOR;
                        break;
                    default:
                        System.out.println("error");
                        System.exit(-1);
                }
                meta.type = type;
                // 当前器件总的输入数量
                int k = Integer.parseInt(elements[1]);
                // 记录每个输入
                List<Integer> input = new ArrayList<>();
                List<Integer> receive = new ArrayList<>();
                for(int j =0;j < k; j++) {
                    String desc = elements[j+2];
                    // Attention! 编号不只一位数！
                    if(desc.charAt(0) == 'I') { // has input to connect to
                        input.add(Integer.parseInt(desc.substring(1))); // 保存来自外部输入的编号
                    } else {
                        int getindex = Integer.parseInt(desc.substring(1)) - 1; // receive from，来自元器件的输入，保存的是元器件的下标（从0开始）
                        receive.add(getindex);

                        graph[getindex][i] = true; // 记录入边
                        intoDegree[i]++; // 入度加一
                    }
                }
                meta.totalInputNum = k;
                meta.inputs = input;
                meta.receive = receive;
                meta.states = new ArrayList<>();
                metaList.add(meta);
            }
            // 第二部分的输入
            int S = Integer.parseInt(scanner.nextLine()); // electron road run times
            List<List<Integer>> allInputs = new ArrayList<>();
            List<List<Integer>> allResults = new ArrayList<>();
            for(int i =0; i < S; i++) { // 读取输入，input的编号是以下标为
                elements = scanner.nextLine().split(" ");
                List<Integer> temp = new ArrayList<>();
                for(int j = 0; j < elements.length; j++) {
                    temp.add(Integer.parseInt(elements[j]));
                }
                allInputs.add(temp);
            }
            for(int i =0; i < S; i++) {
                elements = scanner.nextLine().split(" ");
                List<Integer> temp = new ArrayList<>();
                for(int j = 0; j < elements.length; j++) {
                    temp.add(Integer.parseInt(elements[j]));
                }
                allResults.add(temp); // 需要呈现结果的元器件编号
            }

            // 判断环路
            Queue<Integer> queue = new LinkedList<>();
            List<Integer> sortOrder = new LinkedList<>(); // 拓扑排序序列，保存的是元件的下标
            for (int i = 0; i < N; i++) {
                if (intoDegree[i] == 0) {
                    queue.add(i);
                    sortOrder.add(i);
                }
            }
            while(!queue.isEmpty()) {
                int node = queue.poll(); // 弹出一个元素
                for (int i = 0; i < N; i++) {
                    if (graph[node][i]) {
                        intoDegree[i]--;
                        graph[node][i] = false; // 删除这条边
                        if (intoDegree[i] == 0) {
                            queue.add(i);
                            sortOrder.add(i);
                        }
                    }
                }
            }
            if (sortOrder.size() != N) {
                System.out.println("LOOP");
                continue ;
            }

            // the following is solving
            // 这个电路需要运行S次
            for(int i = 0; i < S; i++) {
                List<Integer> inputs = allInputs.get(i);
                List<Integer> results = allResults.get(i);

                for (Integer metaIndex : sortOrder) {
                    Meta meta = metaList.get(metaIndex);
                    for(Integer inputIndex : meta.inputs) {
                        meta.states.add(inputs.get(inputIndex - 1) == 1);
                    }
                    for(Integer receiveIndex : meta.receive) {
                        meta.states.add(metaList.get(receiveIndex).result);
                    }
                    meta.calcuResult();
                }

                for(int r = 1; r <= results.get(0); r++) {
                    System.out.print(metaList.get(results.get(r) - 1).result == true ? 1 : 0);
                    System.out.print(" ");
                }
                // 清空之前的状态
                metaList.forEach( meta ->  {
                    meta.states = new ArrayList<>();
                    meta.result = null;
                });
                System.out.println();
            }
        }
    }

    // pass
    public static void testMeta(){
        Meta meta = new Meta();
        meta.type = Func.NOR;
        meta.states = new ArrayList<>();
        meta.states.add(false);
        meta.states.add(false);
        meta.states.add(true);
        meta.calcuResult();
        System.out.println(meta.result);
    }
}