刷题：徒步旅行中的补给问题

用户221358532522
383 阅读5分钟

刷题：徒步旅行中的补给问题

Created: 2024年11月5日 19:56 Class: 刷题

题目解析

徒步旅行中的补给问题

问题描述

小R正在计划一次从地点A到地点B的徒步旅行，总路程需要 N 天。为了在旅途中保持充足的能量，小R每天必须消耗1份食物。幸运的是，小R在路途中每天都会经过一个补给站，可以购买食物进行补充。然而，每个补给站的食物每份的价格可能不同，并且小R最多只能同时携带 K 份食物。

现在，小R希望在保证每天都有食物的前提下，以最小的花费完成这次徒步旅行。你能帮助小R计算出最低的花费是多少吗？

测试样例

样例1：

输入：n = 5 ,k = 2 ,data = [1, 2, 3, 3, 2]

输出：9

样例2：

输入：n = 6 ,k = 3 ,data = [4, 1, 5, 2, 1, 3]

输出：9

样例3：

输入：n = 4 ,k = 1 ,data = [3, 2, 4, 1]

输出：10

读题

不要忘记，没吃完也是可以买的，只要还有空间。

举个例子：n=6, k=3, data = [4, 1, 5, 2, 3, 3]. 第一天花四块钱买一份充充饥；第二天“未雨绸缪，斥巨资”花三块钱买了包含第二天的三天的口粮；到四天，两块钱好便宜，虽然我还剩一份，但是为了明后两天，全买了！欸，巧不巧，刚刚好！拢共花了11块钱，真划算！

思路

滑动窗口+单调队列：限制条件用滑动窗口，在里面找最小（大）值用单调队列。

相似的题目：leetcode 239. 滑动窗口最大值

单调队列

单调队列指的就是队列里面的元素是单调的，你自己制定进出规则，维护好就可以。

这个队列不是严格意义上队列，两边都可以出，规则可以自己制定的。

先举个例子：还是这个[4, 1, 5, 2, 3, 3]，如果不考虑滑动窗口的话，只是实现一个单调递增队列，进出是这样的

  1. 4进入。因为初始是空的，进就完了 —> [4]
  2. 1，和4比，进不去，把4踢了，1进入 —> [1]
  3. 5，5 >1，进！ —> [1, 5]
  4. 2，先和5比，5太大，把5踢了，和1比，嗯，2>1，可以 —> [1, 2]
  5. 3，进 —> [1, 2, 3]
  6. 3，进 —> [1, 2, 3, 3]

维护一个单调递增队列的进出规则就是：

  • 队列是空的，进
  • 数比队列最后一个大，进
  • 比队列最后一个小，把最后的那个弹出，再比较最后一个，直至找到一个比要插入的这个数小的，或者全弹完了，就可以把数插进队列最后了。

递减同理。

滑动窗口的单调队列

有了窗口大小的限制，不用担心。

滑动窗口是什么样子：

  1. [[4], 1, 5, 2, 3, 3]
  2. [[4, 1], 5, 2, 3, 3]
  3. [[4, 1, 5], 2, 3, 3]
  4. [4, [1, 5, 2], 3, 3]
  5. [4, 1, [5, 2, 3], 3]
  6. [4, 1, 5, [2, 3, 3]]

只需要把窗口滑过去的那个值，从队列中删掉就好了，比如从第3行到第4行，只需要考虑从队列中删掉4就好了。怎么删？这里只要想明白，队列的第一个值，肯定在你要删的那个数的后面。举个例子，你不是要删4嘛，那现在队列里的第一个值是什么，是1啊，你不信可以在推一推后面的。好！我们把滑动窗口加上，重新构建一个单调递增队列：

  1. [[4], 1, 5, 2, 3, 3]：4进入 —> [4]
  2. [[4, 1], 5, 2, 3, 3]：1，和4比，进不去，把4踢了，1进入 —> [1]
  3. [[4, 1, 5], 2, 3, 3]：5，5 >1，进！ —> [1, 5]
  4. [4, [1, 5, 2], 3, 3]：2，先和5比，5太大，把5踢了，和1比，嗯，2>1，可以。要把4踢了，正好4不在，不用动了 —> [1, 2]
  5. [4, 1, [5, 2, 3], 3]：3，进。要把1踢了，队列首位就是1，删掉 —> [2, 3]
  6. [4, 1, 5, [2, 3, 3]]：3，进 —> [2, 3, 3]

妙啊！

题目思路

回到这个题上，我是不是只需要吧每一步的队列首位加起来，就是答案了呢！4+1+1+1+2+2 = 11！

代码

import java.util.*;

public class Main {
    public static int solution(int n, int k, int[] data) {
        // Edit your code here
        int res = 0;
        LinkedList<Integer> stack = new LinkedList<>();
        int len = data.length;
        for(int i = 0; i<len; i++){
            if(stack.isEmpty() || data[i] >= stack.getLast()){
                stack.addLast(data[i]);
            }else{
                while(!stack.isEmpty() && data[i] < stack.getLast()){
                    stack.removeLast();
                }
                stack.addLast(data[i]);
            }
            if(i>k-1 && stack.getFirst() == data[i-k]){
                stack.removeFirst();
            }
            res+=stack.getFirst();
        }
        return res;
    }
    
    public static void main(String[] args) {
        // Add your test cases here

        System.out.println(solution(5, 2, new int[]{1, 2, 3, 3, 2}) == 9);
        System.out.println(solution(6, 3, new int[]{4, 1, 5, 2, 1, 3}) == 9);
        System.out.println(solution(4, 1, new int[]{3, 2, 4, 1}) == 10);
        
    }
}

总结

一开始就是奔着练一下贪心的题，在贪心划分里找题做。结果做这道题时，总是想着局部最优是什么，思维也不活络，怎么也想不到这个局部最优是啥。后来看了别人的分析，提到最小堆，就突然想起来，单调队列不就类似与最大最小堆的嘛，然后就想起来做过的滑动窗口的单调队列这个题。

可能还是刷的题不够吧，在多见见题，没准就可以灵光一现了。

avatar
文章
阅读
粉丝