测试数据#4 in：3 8 6 4 5 1 7 8 4 2 6 5 2 4 1 2 6 8 3 7 1 3 3 7 5 8 1 2 3 1 3 2 3 2 1 2 1 3 3 1 2 1 2 3 3 1 2 1 2 3 4 5 2 3 5 3 6 4 2 4 5 6 3 1 7 7 5 3 4 4 5 8 5 9
out: 47
自己代码运行结果:41

实在找不到问题，注释尽量写了，希望有大佬能帮忙看一下

import java.util.Scanner;
public class P1065 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt(),
                n = sc.nextInt();
        int[] order = new int[m*n];
        for (int i = 0; i < order.length; i++) {
            order[i] = sc.nextInt();
        }
        // 所使用的机器编号
        int[][] machineCode = new int[n][m];
        for (int i = 0; i < machineCode.length; i++) {
            for (int j = 0; j < m; j++) {
                machineCode[i][j] = sc.nextInt();
            }
        }
        // 每个单件每个工序用时
        int[][] runTime = new int[n][m];
        for (int i = 0; i < runTime.length; i++) {
            for (int j = 0; j < m; j++) {
                runTime[i][j] = sc.nextInt();
            }
        }
        // 时间轴，每多一个机器，多一条时间轴
        int[][] timelines = new int[m][10000];

        // 每个单件上一个工序结束点
        int[] endPoint = new int[n];

        // 每个单件的工序数
        int[] procs = new int[n];

        for (int i = 0; i < order.length; i++) {
            // 单件编号
            int single = order[i]-1;
            // 工序
            int proc = procs[single]++;

            // 该单件这次工序所耗费的时间
            int costTime = runTime[single][proc];
            // 该单件所使用的机器
            int useMachine = machineCode[single][proc]-1;

            // 找到这个工序所用的机器时间轴，从头判断是否有整块时间来加工该工件
            for (int j = endPoint[single]; j < timelines[useMachine].length; j++) {
                boolean isOk = true;
                for (int k = j; k < costTime+j; k++) {
                    if (timelines[useMachine][j] != 0){
                        isOk = false;
                        break;
                    }
                }
                // 如果这一整块时间都是空的，就把工件放在这个时间加工
                if (isOk){
                    // 占用机器这段时间
                    for (int k = j; k < costTime+j; k++) {
                        // 把这些地方的元素改成该单件的编号
                        timelines[useMachine][k] = single+1;
                    }
                    // 记录该工件这一道工序结束时间点
                    endPoint[single] = j + costTime;
                    break;
                }
            }
        }
        int finalTime = 0;
        for (int i = 0; i < endPoint.length; i++) {
            finalTime = Math.max(endPoint[i],finalTime);
        }
        System.out.println(finalTime);
    }
}