LeetCode 1475. Final Prices With a Special Discount in a Shop

You are given an integer array prices where prices[i] is the price of the ith item in a shop.

There is a special discount for items in the shop. If you buy the ith item, then you will receive a discount equivalent to prices[j] where j is the minimum index such that j > i and prices[j] <= prices[i]. Otherwise, you will not receive any discount at all.

Return an integer array answer where answer[i] is the final price you will pay for the ith item of the shop, considering the special discount.

Example 1:

Input: prices = [8,4,6,2,3]
Output: [4,2,4,2,3]
Explanation: 
For item 0 with price[0]=8 you will receive a discount equivalent to prices[1]=4, therefore, the final price you will pay is 8 - 4 = 4.
For item 1 with price[1]=4 you will receive a discount equivalent to prices[3]=2, therefore, the final price you will pay is 4 - 2 = 2.
For item 2 with price[2]=6 you will receive a discount equivalent to prices[3]=2, therefore, the final price you will pay is 6 - 2 = 4.
For items 3 and 4 you will not receive any discount at all.

Example 2:

Input: prices = [1,2,3,4,5]
Output: [1,2,3,4,5]
Explanation: In this case, for all items, you will not receive any discount at all.

Example 3:

Input: prices = [10,1,1,6]
Output: [9,0,1,6]

Constraints:

• 1 <= prices.length <= 500
• 1 <= prices[i] <= 1000

---

相当于就是求每个元素以后第一个<=它的元素的大小，brute force很简单

class Solution {
    public int[] finalPrices(int[] prices) {
        int[] result = new int[prices.length];
        for (int i = 0; i < prices.length; i++) {
            int discount = 0;
            for (int j = i + 1; j < prices.length; j++) {
                if (prices[j] <= prices[i]) {
                    discount = prices[j];
                    break;
                }
            }
            result[i] = prices[i] - discount;
        }
        return result;
    }
}

嗯，一道题当然不可能就这么简单的，没错，这题可以直接O(n)解决，借助monotonic stack的思想，类似于496：LeetCode 496. Next Greater Element I_wenyq7的博客-CSDN博客

496是求下一个最大的元素，所以maintain了一个递减的stack，每次push进stack的元素都是当前最小的，所以在它之前要被pop的元素的next greater element就是新push进来的。而这题是求下一个小于等于它的元素，所以就需要一个非递减的stack，也就是每次push进来的都>=当前的stack top，那么在它之前被pop出来的下一个<=被pop出来的，就是它了。

以及这里我们可以直接在stack里存index，这样就方便直接根据index改数组了。

但是莫名其妙的，这个方法花了3ms，但是brute force只花了1ms。

class Solution {
    public int[] finalPrices(int[] prices) {
        int[] result = prices.clone();
        Deque<Integer> stack = new ArrayDeque<>();  // store the index, not price
        for (int i = 0; i < prices.length; i++) {
            while (!stack.isEmpty() && prices[stack.peek()] >= prices[i]) {
                result[stack.pop()] -= prices[i];
            }
            stack.push(i);
        }
        return result;
    }
}