标签：贪心，简单

思路：

每次找到当前的数组中的最小的价格，该补给站记为J,，该补给站之后的路程所需的全部物资在此处购买即可，对于该补给站之前的路程，又回到原问题，开始位置到J的所需的最小花费。递归 + 贪心

补给站最优花费问题

问题描述

小U计划进行一场从地点A到地点B的徒步旅行，旅行总共需要 M 天。为了在旅途中确保安全，小U每天都需要消耗一份食物。在路程中，小U会经过一些补给站，这些补给站分布在不同的天数上，且每个补给站的食物价格各不相同。

小U需要在这些补给站中购买食物，以确保每天都有足够的食物。现在她想知道，如何规划在不同补给站的购买策略，以使她能够花费最少的钱顺利完成这次旅行。

• M：总路程所需的天数。
• N：路上补给站的数量。
• p：每个补给站的描述，包含两个数字 A 和 B，表示第 A 天有一个补给站，并且该站每份食物的价格为 B 元。

保证第0天一定有一个补给站，并且补给站是按顺序出现的。

测试样例

样例1：

输入：m = 5 ,n = 4 ,p = [[0, 2], [1, 3], [2, 1], [3, 2]]
输出：7

样例2：

输入：m = 6 ,n = 5 ,p = [[0, 1], [1, 5], [2, 2], [3, 4], [5, 1]]
输出：6

样例3：

输入：m = 4 ,n = 3 ,p = [[0, 3], [2, 2], [3, 1]]
输出：9

public class Main {
    public static int solution(int m, int n, int[][] p) {
        /*
         * 每次把路程分为两段，找到最便宜的补给站之前，和之后
         * 可以通过递归的方法实现，同时使用了贪心的思想
         */
        int cost = get(0,m,p,n);
        System.out.println(cost);
        return cost;
    }
    public static int get(int cost,int m,int [][]p,int d){
        //m记录剩余的路程的天数，d记录当前的数组的上界
        //递归的出口
        if(d <= 0) return cost;

        int j = caculate(p,d);
        int minPrice = p[j][1];
        cost = cost + minPrice * (m - p[j][0]);
        int days = p[j][0];
        return get(cost,days, p, j);
    }

    public static int caculate(int [][] p,int j){
        //搜索当前的最小的价格对应的索引,j为迭代的上界
        int result = 0;
        int min = p[0][1];

        for(int i = 0; i < j; i++){
            if(p[i][1] < min){
                min = p[i][1];
                result = i;
            }
        }

        return result;

    }

    public static void main(String[] args) {
        // Add your test cases here
        System.out.println(solution(5, 4, new int[][]{{0, 2}, {1, 3}, {2, 1}, {3, 2}}) == 7);
    }
}