g1601_1700.s1642_furthest_building_you_can_reach.Solution Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation
Java-based LeetCode algorithm problem solutions, regularly updated
There is a newer version: 1.38
package g1601_1700.s1642_furthest_building_you_can_reach;

// #Medium #Array #Greedy #Heap_Priority_Queue
// #2022_04_21_Time_13_ms_(98.96%)_Space_58.5_MB_(75.89%)

import java.util.PriorityQueue;

/**
 * 1642 - Furthest Building You Can Reach\.
 *
 * Medium
 *
 * 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:**
 *
 * ![](https://assets.leetcode.com/uploads/2020/10/27/q4.gif)
 *
 * **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.
 *
 * **Example 2:**
 *
 * **Input:** heights = [4,12,2,7,3,18,20,3,19], bricks = 10, ladders = 2
 *
 * **Output:** 7
 *
 * **Example 3:**
 *
 * **Input:** heights = [14,3,19,3], bricks = 17, ladders = 0
 *
 * **Output:** 3
 *
 * **Constraints:**
 *
 * *   1 <= heights.length <= 10⁵
 * *   1 <= heights[i] <= 10⁶
 * *   0 <= bricks <= 10⁹
 * *   `0 <= ladders <= heights.length`
**/
public class Solution {
    public int furthestBuilding(int[] heights, int bricks, int ladders) {
        PriorityQueue minHeap = new PriorityQueue<>();
        int i = 0;
        // we'll assume to use ladders for the first l jumps and adjust it afterwards
        for (; i < heights.length - 1 && minHeap.size() < ladders; i++) {
            int diff = heights[i + 1] - heights[i];
            if (diff > 0) {
                minHeap.offer(diff);
            }
        }
        while (i < heights.length - 1) {
            int diff = heights[i + 1] - heights[i];
            if (diff > 0) {
                if (!minHeap.isEmpty() && minHeap.peek() < diff) {
                    bricks -= minHeap.poll();
                    minHeap.offer(diff);
                } else {
                    bricks -= diff;
                }
                if (bricks < 0) {
                    return i;
                }
            }
            i++;
        }
        return i;
    }
}