#华为笔试#9.14笔试第2题

public class Exer2Preview {
    /*
        题目：
            大致题意如下，在某一次网络传输中，有m个数据包需要进行传输，每个数据包都有
        自己的大小和传输时长。此时有n个传输数据的通道，每个通道都有自己的传输能力上限，
        即只能传输数据包大小 <= 自己上限的数据包，且每个通道都能同时缓存m个数据包。
            求传输完这m个数据包需要的最短时间？
        输入：m ——数据包的个数
             n ——传输数据的通道的个数
             n个数，分别代表每个通道的传输能力
             m个数，分别代表每个数据包的大小
             m个数，分别代表每个数据包的传输时长
        输出：传输完这m个数据包需要的最短时间
     */
    public static void main(String[] args) {

        // 处理输入
        Scanner scanner = new Scanner(System.in);
        int numPackets = scanner.nextInt();
        int numChannels = scanner.nextInt();
        // channels[i][0]:代表通道i的传输能力
        // channels[i][1]:代表通道i的负载，即已经工作的时长，初始时都为0
        int[][] channels = new int[numChannels][2];
        for(int i = 0;i < numChannels;i++){
            channels[i][0] = scanner.nextInt();
        }
        // packets[i][0]:代表数据包i的大小
        // packets[i][1]:代表数据包i的传输时长
        int[][] packets = new int[numPackets][2];
        for(int i = 0;i < numPackets;i++){
            packets[i][0] = scanner.nextInt();
        }
        for(int i = 0;i < numPackets;i++){
            packets[i][1] = scanner.nextInt();
        }

        // 中间过程
        /*
            算法思想：
                贪心 + 暴力
                首先对所有数据包进行排序，先按传输时长降序排，再按大小升序排
                ① 先处理传输时间长的数据包
                ② 选择最早空闲的通道(即已经工作时间最短的通道)，这样可以最小
                  限度地增加通道的处理时间
                ③ 若最早空闲的通道有多个，则选择传输能力较小的通道，把传输能
                  力大的通道留给后面可能存在的比自己大的数据包
         */
        // 排序操作
        Arrays.sort(packets, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[1] < o2[1]){
                    return 1;
                }else if(o1[1] > o2[1]){
                    return -1;
                }else{
                    if(o1[0] < o2[0]){
                        return -1;
                    }else if(o1[0] > o2[0]){
                        return 1;
                    }else{
                        return 0;
                    }
                }
            }
        });

        // 遍历所有的数据包
        for(int[] packet : packets){
            // minWorkingTime：工作时间最短的通道的工作时长
            int minWorkingTime = Integer.MAX_VALUE;
            // 传输当前数据包的通道的编号，初始值为0
            int channel = 0;

            // 遍历所有的通道
            for(int i = 0;i < numChannels;i++){
                if(channels[i][0] >= packet[0]){
                    if(channels[i][1] < minWorkingTime){
                        minWorkingTime = channels[i][1];
                        channel = i;
                    }else if(channels[i][1] == minWorkingTime && channels[i][0] < channels[channel][0]){
                        channel = i;
                    }
                }
            }
            channels[channel][1] = channels[channel][1] + packet[1];
        }
        // 处理输出
        int allTasksTime = 0;
        for(int i = 0;i < numChannels;i++){
            if(channels[i][1] > allTasksTime){
                allTasksTime = channels[i][1];
            }
        }
        System.out.println(allTasksTime);
    }
}