983. 最低票价（Java）（一条龙，动归正向迭代，一维dp）

1 题目

在一个火车旅行很受欢迎的国度，你提前一年计划了一些火车旅行。在接下来的一年里，你要旅行的日子将以一个名为 days 的数组给出。每一项是一个从 1 到 365 的整数。

火车票有三种不同的销售方式：

一张为期一天的通行证售价为 costs[0] 美元；
一张为期七天的通行证售价为 costs[1] 美元；
一张为期三十天的通行证售价为 costs[2] 美元。
通行证允许数天无限制的旅行。 例如，如果我们在第 2 天获得一张为期 7 天的通行证，那么我们可以连着旅行 7 天：第 2 天、第 3 天、第 4 天、第 5 天、第 6 天、第 7 天和第 8 天。

返回你想要完成在给定的列表 days 中列出的每一天的旅行所需要的最低消费。

示例 1：

输入：days = [1,4,6,7,8,20], costs = [2,7,15]
输出：11
解释：
例如，这里有一种购买通行证的方法，可以让你完成你的旅行计划：
在第 1 天，你花了 costs[0] = $2 买了一张为期 1 天的通行证，它将在第 1 天生效。
在第 3 天，你花了 costs[1] = $7 买了一张为期 7 天的通行证，它将在第 3, 4, …, 9 天生效。
在第 20 天，你花了 costs[0] = $2 买了一张为期 1 天的通行证，它将在第 20 天生效。
你总共花了 $11，并完成了你计划的每一天旅行。
示例 2：

输入：days = [1,2,3,4,5,6,7,8,9,10,30,31], costs = [2,7,15]
输出：17
解释：
例如，这里有一种购买通行证的方法，可以让你完成你的旅行计划：
在第 1 天，你花了 costs[2] = $15 买了一张为期 30 天的通行证，它将在第 1, 2, …, 30 天生效。
在第 31 天，你花了 costs[0] = $2 买了一张为期 1 天的通行证，它将在第 31 天生效。
你总共花了 $17，并完成了你计划的每一天旅行。

提示：

1 <= days.length <= 365
1 <= days[i] <= 365
days 按顺序严格递增
costs.length == 3
1 <= costs[i] <= 1000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-cost-for-tickets
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2 Java

该题与 322. 零钱兑换 类似，都是动态规划
相同点：
目标金额amount 等价于 最后一个旅游日期days[day.length - 1]
最少硬币数（单次增长1） 等价于 最低消费（单次增长costs[]）
硬币面值（coin[]） 等价于 通行证天数（1，7，30）
不同在于：
前者给定的是硬币面值coins[]，后者给定的是最低消费的单次增长值costs[]
有一个错位，导致322 会多一层 for 循环用于获得硬币面值，而通行证天数固定

2.1 方法一（迭代；自底向上动态规划；带备忘录的正向暴力）

本题难点在于初始条件不明，状态方程不明。
1 备忘录的初始化，旅行日期为∞，非旅行日期为0
2 非旅行日期消费 = 前一天（前一个旅行日期）消费
3 状态方程：某旅行日期消费，仅之前的某三天相关；且存在特殊情况（当前日期 ≤ 单张通行证天数）

class Solution {
    public int mincostTickets(int[] days, int[] costs) {
        if(days == null || days.length < 1 || costs == null || costs.length < 1)    return 0;
        // 创建备忘录，初始化！！！非旅行日期状态方程改变
        int[] dp = new int[days[days.length - 1] + 1];
        for(int day: days)  dp[day] = Integer.MAX_VALUE;    // 旅行日期为∞，非旅行日期为0

        // 外层for状态步进
        for(int i = 1; i < dp.length; i++){
            // 特殊情况
            if(dp[i] == 0)  dp[i] = dp[i - 1];  // 非旅行日期消费 = 前一天（前一旅行日期）消费
            // 内层for多路择优
            else{
                // 某旅行日期消费，仅之前的某三天相关；且存在特殊情况（当前日期 ≤ 单张通行证天数）
                int dp0 = i > 1 ? dp[i - 1] + costs[0] : costs[0];
                int dp1 = i > 7 ? dp[i - 7] + costs[1] : costs[1];
                int dp2 = i > 30 ? dp[i - 30] + costs[2] : costs[2];
                dp[i] = Math.min(dp0, Math.min(dp1, dp2));
            }
        }
        return dp[dp.length - 1];
    }
}

2.2 方法二（优化递归；自顶向下动态规划；带备忘录的逆向暴力）

备忘录初始化赋值
初始条件和特殊情况，要能使整个方程不断迭代（一层一层的从递归最深层出来）
若某种初始条件 / 特殊情况过于复杂，可以从方法开头挪至状态方程部分

class Solution {
    /* 
        day天开销 指0~day天总开销
        递归返回值：day天的开销
        n：最后一天旅游日
        初始条件：第0天开销=0
        特殊情况：非旅游日开销 = 前一天开销
        状态方程：对于每一步来说，可能从三个状态跳过来
    */

    HashSet<Integer> daySet = new HashSet<>();

    public int mincostTickets(int[] days, int[] costs) {
        if(days == null || days.length < 1 || costs == null || costs.length < 1)    return 0;
        // 创建备忘录
        int[] memory = new int[days[days.length - 1] + 1];
        Arrays.fill(memory, Integer.MAX_VALUE);

        for(int day: days)  daySet.add(day);

        return helper(days, costs, days[days.length - 1], memory);
    }

    public int helper(int[] days, int[] costs, int day, int[]memory){
        // 查询备忘录
        if(memory[day] != Integer.MAX_VALUE)	return memory[day];

        // if判断初始条件
        if(day == 0)	return memory[day] = 0;
        // 特殊情况
        if(!daySet.contains(day))  return memory[day] = helper(days, costs, day - 1, memory);

        // for循环状态方程
        int payment0 = day > 1 ? helper(days, costs, day - 1, memory) + costs[0] : costs[0];
        int payment1 = day > 7 ? helper(days, costs, day - 7, memory) + costs[1] : costs[1];
        int payment2 = day > 30 ? helper(days, costs, day - 30, memory) + costs[2] : costs[2];
        return memory[day] = Math.min(payment0, Math.min(payment1, payment2));
    }
}

2.3 方法三（递归；逆向暴力）

超出时间限制

class Solution {
    /* 
        day天开销 指0~day天总开销
        递归返回值：day天的开销
        n：最后一天旅游日
        初始条件：第0天开销=0
        特殊情况：非旅游日开销 = 前一天开销
        状态方程：对于每一步来说，可能从三个状态跳过来
    */


    HashSet<Integer> daySet = new HashSet<>();

    public int mincostTickets(int[] days, int[] costs) {
        if(days == null || days.length < 1 || costs == null || costs.length < 1)    return 0;

        for(int day: days)  daySet.add(day);

        return helper(days, costs, days[days.length - 1]);
    }

    public int helper(int[] days, int[] costs, int day){
        // if判断初始条件
        if(day == 0)	return 0;
        // 特殊情况：非旅游日开销 = 前一天开销
        if(!daySet.contains(day))  return helper(days, costs, day - 1);

        // for循环状态方程
        int payment0 = day > 1 ? helper(days, costs, day - 1) + costs[0] : costs[0];
        int payment1 = day > 7 ? helper(days, costs, day - 7) + costs[1] : costs[1];
        int payment2 = day > 30 ? helper(days, costs, day - 30) + costs[2] : costs[2];
        return Math.min(payment0, Math.min(payment1, payment2));
    }
}