【013·未解】1642. 可以到达的最远建筑【优先队列 || 二分查找】

给你一个整数数组 heights ，表示建筑物的高度。另有一些砖块 bricks 和梯子 ladders 。
你从建筑物 0 开始旅程，不断向后面的建筑物移动，期间可能会用到砖块或梯子。
当从建筑物 i 移动到建筑物 i+1（下标 从 0 开始 ）时：
如果当前建筑物的高度 大于或等于 下一建筑物的高度，则不需要梯子或砖块 如果当前建筑的高度 小于 下一个建筑的高度，您可以使用 一架梯子 或(h[i+1] - h[i]) 个砖块 如果以最佳方式使用给定的梯子和砖块，返回你可以到达的最远建筑物的下标（下标 从 0 开始 ）。

1. 优先队列：用 PriorityQueue 维护排在前 ladders 的高度差。当队列中元素超过梯子数量时， poll 最小元素，对其使用砖块
2. 二分查找：可能到达的楼房索引为【0,heights - 1】；基于此，使用二分查找，找出可以到达的最大值

/*
 * Copyright (c) Huawei Technologies Co., Ltd. 2023-2023. All rights reserved.
 */

package com.huawei.prac;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;

public class Solution4th {
    public static void main(String[] args) {
        int[] heights = new int[] {4, 12, 2, 7, 3, 18, 20, 3, 19};
        int bricks = 10;
        int ladders = 2;
        System.out.println(furthestBuilding(heights, bricks, ladders));
        System.out.println(furthestBuildingNd(heights, bricks, ladders));
    }

    /**
     * 1642. 可以到达的最远建筑[贪心思想 + 优先队列 || 二分查找]
     * 用 PriorityQueue 维护排在前 ladders 的高度差。
     * 当队列中元素超过梯子数量时， poll 最小元素，对其使用砖块
     *
     * @param heights 楼房高度数组
     * @param bricks 砖块数量
     * @param ladders 梯子数量
     * @return 最远可达楼房的索引
     */
    public static int furthestBuilding(int[] heights, int bricks, int ladders) {
        Queue<Integer> topDifAsc = new PriorityQueue<>();
        int difHeight;
        for (int i = 0; i < heights.length - 1; i++) {
            difHeight = heights[i + 1] - heights[i];
            if (difHeight > 0) {
                topDifAsc.offer(difHeight);
                if (topDifAsc.size() > ladders) {
                    bricks -= topDifAsc.poll();
                }
                if (bricks < 0) {
                    return i;
                }
            }
        }
        return heights.length - 1;
    }

    /**
     * 二分查找：可能到达的楼房索引为【0,heights - 1】
     * 基于此，使用二分查找，找出可以到达的最大值
     *
     * @param heights 楼房高度数组
     * @param bricks 砖块数量
     * @param ladders 梯子数量
     * @return 最远可达楼房的索引
     */
    public static int furthestBuildingNd(int[] heights, int bricks, int ladders) {
        int left = 0;
        int right = heights.length - 1;
        while (left < right) {
            int mid = right - (right - left) / 2;
            if (canReach(heights, bricks, ladders, mid)) {
                left = mid;
            } else {
                right = mid - 1;
            }
        }
        return left;
    }

    private static boolean canReach(int[] heights, int bricks, int ladders, int index) {
        List<Integer> diffs = new ArrayList<>();
        for (int i = 1; i <= index; ++i) {
            if (heights[i] > heights[i - 1]) {
                diffs.add(heights[i] - heights[i - 1]);
            }
        }

        Collections.sort(diffs);
        int neededBricks = 0;
        for (int i = 0; i < diffs.size() - ladders; ++i) {
            neededBricks += diffs.get(i);
        }

        return neededBricks <= bricks;
    }
}