leetcode 1642. Furthest Building You Can Reach（能到达的最远的建筑）

You are given an integer array heights representing the heights of buildings, some bricks, and some ladders.

You start your journey from building 0 and move to the next building by possibly using bricks or ladders.

While moving from building i to building i+1 (0-indexed),

If the current building’s height is greater than or equal to the next building’s height, you do not need a ladder or bricks.
If the current building’s height is less than the next building’s height, you can either use one ladder or (h[i+1] - h[i]) bricks.
Return the furthest building index (0-indexed) you can reach if you use the given ladders and bricks optimally.

Example 1:

Input: heights = [4,2,7,6,9,14,12], bricks = 5, ladders = 1
Output: 4
Explanation: Starting at building 0, you can follow these steps:

• Go to building 1 without using ladders nor bricks since 4 >= 2.
• Go to building 2 using 5 bricks. You must use either bricks or ladders because 2 < 7.
• Go to building 3 without using ladders nor bricks since 7 >= 6.
• Go to building 4 using your only ladder. You must use either bricks or ladders because 6 < 9.
  It is impossible to go beyond building 4 because you do not have any more bricks or ladders.

你手上有砖和梯子两种工具，当下一个楼比当前楼更高的时候，就要借助砖或者梯子上去，
选砖的话就需要 高度差 块砖，选梯子的话只需要一个梯子。
问最远能到达第几个建筑，从下标0开始。

思路：

如果高度差很大的话，需要很多块砖，但是只需要一个梯子，
一个直觉的想法就是高度差最大的那几个用梯子，剩下的用砖，就能资源最大化，走得更远。

那显然高度差不是排好序的，也不能排序，毕竟楼就在那里不能移动。
所以有一个想法就是先用砖，砖不够的时候把目前为止最大的高度差的那个地方把砖换成梯子，同时把砖回收回来下次用。

那怎样找到目前为止最大的高度差呢，用最大堆即可。

public int furthestBuilding(int[] heights, int bricks, int ladders) {
    int n = heights.length;
    if(n == 1) return 0;
    
    
    PriorityQueue<Integer> queue = new PriorityQueue<>(Collections.reverseOrder());
    
    for(int i = 0; i < n - 1; i++) {
        if(heights[i] >= heights[i+1]) continue;
        
        bricks -= heights[i+1] - heights[i];
        queue.add(heights[i+1] - heights[i]);
        
        if(bricks < 0) {
            bricks += queue.poll();
            if(ladders > 0) ladders --;
            else return i;
        }
        
    }
    return n - 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

上面这样写时间效率不高，因为每一步都要把高度差加到queue里

public int furthestBuilding(int[] heights, int bricks, int ladders) {
    int n = heights.length;
    if(n == 1) return 0;
    
    
    PriorityQueue<Integer> queue = new PriorityQueue<>(Collections.reverseOrder());
    
    int i;
    for(i = 1; i < heights.length; i++) {
        int heightDiff = heights[i] - heights[i - 1];
        
        if(heightDiff <= 0) {
            continue;
        } 
        
        if(heightDiff <= bricks) {
            bricks -= heightDiff;
            queue.offer(heightDiff);
        } else if(ladders > 0){
            if(!queue.isEmpty() && queue.peek() > heightDiff) { //有且有必要换时
                bricks += queue.poll();
                bricks -= heightDiff;
                queue.offer(heightDiff);
            } 
            ladders--;
        } else {
            break;
        }
    }
    
    return i - 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32