华为2019暑期实习机试03

题目3：

公司咖啡机煮咖啡需要花费时间不一样，一台咖啡机只能著一杯咖啡。每个人带着杯子喝咖啡，喝完咖啡后需要清理杯子。清洁杯子有两种方案：1.使用洗杯器清洁，但只有一个，一次只能洗一个杯子。2.自然晾干。求所有人喝完咖啡并清洁完自己的杯子时间为多少？喝咖啡时间忽略。

输入：

第一行数字T，表示有T组测试数据

每组数据。第一行四个数n,m,x,y;表示n个人，m台咖啡机,x洗杯机清洁时间，y自然晾干时间；第二行为每台咖啡机生产咖啡的时间。

输出：

每组测试数据最短时间。

思路：咖啡机用优先队列<咖啡机,剩余等待时间>，每有一个人，一台咖啡机输出队列生产咖啡，队列中剩余咖啡机更改等待时间。洗杯器贪心思想，在洗杯器清洁时间少，且空闲时优先使用。根据等待时间判断是否空闲。

import java.util.HashMap;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int groupNums = sc.nextInt();
        sc.nextLine();
        while (sc.hasNextLine()) {
            for (int i = 0; i < groupNums; i++) {
                int result = 0;
                String[] strings = sc.nextLine().split(",");
                int persons = Integer.parseInt(strings[0]);
                int machineClean = 0;
                int NatureClean = Integer.parseInt(strings[3]);
                int cleanTime = 0;
                    String[] eachTimeStrings = sc.nextLine().split(",");
                    Integer[] eachTime = new Integer[eachTimeStrings.length];
                    Queue<CaffeeMachine> queue = new PriorityQueue<>();
                    for (int j = 0; j < eachTimeStrings.length; j++) {
                        Integer time = Integer.parseInt(eachTimeStrings[j]);
                        eachTime[j] = time;
                        CaffeeMachine machine = new CaffeeMachine(time);
                        //优先队列存储<machine,剩余等待时间>
                        queue.add(machine);
                    }
                    while (persons-- > 0) {
                        CaffeeMachine machine = queue.poll();
                        int time = machine.getTime();
                        for (CaffeeMachine c : queue) {
                            c.changeTime(time);
                        }

                        int initialTime = machine.getInitialTime();
                        //通过上一次生产咖啡到本次的时间间隔，判断清洁器能否使用
                        if (machineClean < NatureClean && time >= machineClean) {
                            result += time;
                            machineClean = Integer.parseInt(strings[2]);
                            cleanTime -= time;
                            cleanTime = Math.max(cleanTime, machineClean);
                        } else if (machineClean < NatureClean && time < machineClean) {
                            result += time;
                            machineClean -= time;
                            cleanTime -= time;
                            cleanTime = Math.max(cleanTime, NatureClean);
                        } else {
                            result += time;
                            cleanTime -= time;
                            cleanTime = Math.max(cleanTime, NatureClean);
                        }
                        //通过HashMap获取该咖啡机的生产咖啡时间,这里可以优化，生产时间以类的属性存储
                        CaffeeMachine newMachine = new CaffeeMachine(initialTime);
                        queue.add(newMachine);
                    }
                result += cleanTime;
                System.out.println(result);
            }
        }
    }
    private static class CaffeeMachine implements Comparable{
        private int time;

        public int getInitialTime() {
            return initialTime;
        }

        private int initialTime;

        public void setTime(int time) {
            this.time = time;
        }

        public int getTime() {
            return time;
        }

        public void changeTime(int t){
            this.time -= t;
        }

        private CaffeeMachine(int time) {
            this.time = time;
            this.initialTime = time;
        }

        @Override
        public int compareTo(Object o) {
            CaffeeMachine cm = (CaffeeMachine) o;
            if (cm.getTime() < this.time) return 1;
            else if (cm.getTime() == this.time) return 0;
            return -1;
        }
    }

}