当前位置：首页 > news >正文

图解LeetCode——1475. 商品折扣后的最终价格（难度：简单）

news 来源：原创 2024/5/19 20:54:01

一、题目

给你一个数组 prices ，其中 prices[i] 是商店里第 i 件商品的价格。

商店里正在进行促销活动，如果你要买第 i 件商品，那么你可以得到与 prices[j] 相等的折扣，其中 j 是满足 j > i 且 prices[j] <= prices[i] 的 最小下标 ，如果没有满足条件的 j ，你将没有任何折扣。

请你返回一个数组，数组中第 i 个元素是折扣后你购买商品 i 最终需要支付的价格。

二、示例

2.1> 示例 1：

【输入】prices = [8,4,6,2,3]
【输出】[4,2,4,2,3]
【解释】
商品 0 的价格为 price[0]=8 ，你将得到 prices[1]=4 的折扣，所以最终价格为 8 - 4 = 4 。
商品 1 的价格为 price[1]=4 ，你将得到 prices[3]=2 的折扣，所以最终价格为 4 - 2 = 2 。
商品 2 的价格为 price[2]=6 ，你将得到 prices[3]=2 的折扣，所以最终价格为 6 - 2 = 4 。
商品 3 和 4 都没有折扣。

2.2> 示例 2：

【输入】prices = [1,2,3,4,5]
【输出】[1,2,3,4,5]
【解释】在这个例子中，所有商品都没有折扣。

2.3> 示例 3：

【输入】prices = [10,1,1,6]
【输出】[9,0,1,6]

提示：

1 <= prices.length <= 500
1 <= prices[i] <= 10^3

三、解题思路

3.1> 思路1：正向遍历 + 模拟

根据题目描述，很容易想到的解题思路就是模拟解题，遍历数组中的每个元素prices[i]，再分别对比i之后的元素，如果发现后续元素小于等于prices[i]，则通过计算两者的差值来获得优惠后的结果。

当然，为了提高空间利用率，我们直接在prices数组中进行赋值即可。代码实现，请参照：4.1> 代码1：正向遍历 + 模拟

3.2> 思路2：逆向遍历 + 单调栈

在思路1中，由于要进行两个元素的对比操作，所以需要两层循环，那么，我们其实可以采用单调栈的方式，通过一次循环，就可以获得最终的结果。此处我们采用逆序遍历的方式。具体操作逻辑是：

case1：如果堆栈中为空，则直接入栈。
case2：如果待入栈的元素大于等于栈顶元素，则计算入栈元素与栈顶元素之差，作为优惠后的价格，然后执行入栈操作。
case3：如果待入栈的元素小于栈顶元素，则执行出栈操作。

思路比较简单，我们以prices = [8,4,6,2,3]为例，看一下具体操作逻辑：

步骤1：遍历prices[4]=3元素，由于堆栈是空的，所以直接将3入栈。
步骤2：遍历prices[3]=2元素，由于小于栈顶元素3，所以将3踢出堆栈，此时堆栈为空，则将2入栈。
步骤3：遍历prices[2]=6元素，由于大于栈顶元素2，所以执行6减2得到优惠价格4，将prices[3]修改为4，并将6入栈。
步骤4：遍历prices[1]=4元素，由于小于栈顶元素6，所以将6踢出堆栈，此时再对比栈顶元素2，由于大于栈顶元素2，所以执行4减2得到优惠价格2，将prices[1]修改为2，并将4入栈。
步骤5：遍历prices[0]=8元素，由于大于栈顶元素4，所以执行8减4得到优惠价格4，将prices[0]修改为4，并将8入栈。

代码实现，请参照：4.2.1> 利用Deque实现单调堆 和 4.2.2> 利用数组实现单调堆

四、代码实现

4.1> 代码1：正向遍历 + 模拟

class Solution {
    public int[] finalPrices(int[] prices) {
        for (int i = 0; i < prices.length; i++) {
            int index = i;
            while(++index < prices.length) {
                if (prices[i] >= prices[index]) {
                    prices[i] = prices[i] - prices[index];
                    break;
                }
            }
        }
        return prices;
    }
}

4.2> 代码2：逆向遍历 + 单调栈

4.2.1> 利用Deque实现单调堆

class Solution {
    public int[] finalPrices(int[] prices) {
        Deque<Integer> deque = new ArrayDeque();
        for (int i = prices.length - 1; i >= 0; i--) {
            while (!deque.isEmpty() && deque.peekLast() > prices[i]) deque.removeLast();
            int result = deque.isEmpty() ? prices[i] : prices[i] - deque.peekLast();
            deque.addLast(prices[i]);
            prices[i] = result;
        }
        return prices;
    }
}

4.2.2> 利用数组实现单调堆

class Solution {
    public int[] finalPrices(int[] prices) {
        int index = -1;
        int[] stack = new int[prices.length];
        for (int i = prices.length - 1; i >= 0; i--) {
            while (index != -1 && stack[index] > prices[i]) index--;
            int result = index == -1 ? prices[i] : prices[i] - stack[index];
            stack[++index] = prices[i];
            prices[i] = result;
        }
        return prices;
    }
}