第 230 场周赛记录（283 / 3727）

前面3题中规中矩， 思路不难，就是代码写得有点慢，被猫吵得有点烦。

第四题，思路想出来了，但是运行程序时各种出错。
比赛结束后重写了以下竟然就对了，看来还是太急了。

以后可以加个技巧：
每次把思路用文字写在注释里，这样也可以提前考虑一些边界条件，不要怕时间不够，就怕写错代码。

如果动态得计算每次的情况会很麻烦。
当 2俩车（高速a和慢速b)合并后，
那在后面的跟车（如果速度快都）其实一开始就在追逐慢速b，那么相遇时间就是和慢速b的时间， 不用考虑a了。

那么就想到了贪心，每次选相遇时间最短的出队，此时就是真正的相遇时间。
接着要改变 该车的跟车的情况， 如果是能相遇的，则改成让他计算和此时合并的慢车相遇的情况。

但是在优先队列中改变数值，比较麻烦， 需要重新push一个新的对象，老的对象无法出队， 需要判断地址是否改变。 实现起来问题太多，没考虑清楚就写了。所以最后写跪了

class Solution {
    static class Car {
        double collisionTime;
        int index;
        int last;
        int next;
        int pos;
        int speed;

        public Car(double collisionTime, int index, int last, int next, int pos, int speed) {
            this.collisionTime = collisionTime;
            this.index = index;
            this.last = last;
            this.next = next;
            this.pos = pos;
            this.speed = speed;
        }

        @Override
        public String toString() {
            return "Car{" +
                    "collisionTime=" + collisionTime +
                    ", index=" + index +
                    ", last=" + last +
                    ", next=" + next +
                    ", pos=" + pos +
                    ", speed=" + speed +
                    '}';
        }
    }

    public double[] getCollisionTimes(int[][] cars) {
        PriorityQueue<Car> queue = new PriorityQueue<>(new Comparator<Car>() {
            @Override
            public int compare(Car car, Car t1) {
                return car.collisionTime > t1.collisionTime ? 1 : -1;
            }
        });

        int minSpeed = Integer.MAX_VALUE;
        Car[] carList = new Car[cars.length];
        for (int i = 0; i < cars.length;i++) {
            int pos = cars[i][0];
            int speed = cars[i][1];
            minSpeed = Math.min(speed, minSpeed);
            Car car;
            if (i + 1 >= cars.length) {
                car = new Car(Double.MAX_VALUE,
                        i, i-1, i+1, pos, speed);
            } else {
                int nextPos = cars[i + 1][0];
                int nextSpeed = cars[i + 1][1];
                car = new Car(getCollsionTime(speed, nextSpeed, nextPos - pos),
                        i, i - 1, i + 1, pos, speed);
            }
            queue.offer(car);
            carList[i] = car;
        }
        //System.out.println(Arrays.toString(carList));

        double[] result = new double[cars.length];
        while (!queue.isEmpty()) {
            Car car = queue.poll();
            if (result[car.index] != 0 || carList[car.index] != car) {
                continue;
            }
            if (car.speed == minSpeed) {
                result[car.index] = -1.0;
                continue;
            }
                        result[car.index] = car.collisionTime;

            // 存在下一辆车
            if (car.next < cars.length) {
                Car nextCar = carList[car.next];
                // 下一辆车的上一个节点要变化
                Car newNextCar = new Car(nextCar.collisionTime, nextCar.index, car.last, nextCar.next, nextCar.pos, nextCar.speed);
                queue.offer(newNextCar);
                carList[newNextCar.index] = newNextCar;
            } else if (car.next == cars.length) {
                // 下游没车了。而自己又是自持colletion最大的？
                result[car.index] = -1.0;
            }
            
            // 存在上一辆车
            if (car.last >= 0) {
                Car lastCar = carList[car.last];
                // 上一俩车的下游车变成了nextCar
                
                double collsionTime;
                if (car.next < cars.length) {
                    Car nextCar = carList[car.next];
                    collsionTime = getCollsionTime(lastCar.speed, nextCar.speed, nextCar.pos - lastCar.pos);
                } else {
                    collsionTime = Double.MAX_VALUE;
                }
                
                Car newLastCar = new Car(collsionTime,
                        lastCar.index, lastCar.last, car.next, lastCar.pos, lastCar.speed
                        );
                queue.offer(newLastCar);
                carList[newLastCar.index] = newLastCar;
            }
        }
        
        for (int i = 0; i < result.length;i++) {
            if (new Double(result[i]).equals(Double.MAX_VALUE)) {
                result[i] = new Double(-1);
            }
        }
        return result;
    }

    public double getCollsionTime(int vLeft, int vRight, int d) {
        if (vLeft > vRight) {
            return (double)(d)/(vLeft - vRight);
        } else {
            return Double.MAX_VALUE;
        }
    }
}