leetcode 983. 最低票价

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

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

• 一张为期一天的通行证售价为 costs[0] 美元；

• 一张为期七天的通行证售价为 costs[1] 美元；

• 一张为期三十天的通行证售价为 costs[2] 美元。

通行证允许数天无限制的旅行。例如，如果我们在第 2 天获得一张为期 7 天的通行证，那么我们可以连着旅行 7 天：第 2 天、第 3 天、第 4 天、第 5 天、第 6 天、第 7 天和第 8 天。

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

题解：

1.一个旅行计划数组

2.三种通行证销售方式：一天:costs[0],七天:costs[1],三十天:costs[2]

3.求花费通行证最低消费

 

示例 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，并完成了你计划的每一天旅行。

提示：

• 1 <= days.length <= 365

• 1 <= days[i] <= 365

• days 按顺序严格递增

• costs.length == 3

• 1 <= costs[i] <= 1000

 

解题思路：动态规划，尽可能的使用一张通行证有效期，才能少花费

尽可能的使用一张通行证是指一张有效期为一天的，旅行当天使用；但是当连续几天的旅行，出于价格的考虑购买有效期更长的通行证是更划算的，为尽可能的最低消费，应当充分使用通行证；比如一张7天的通行证，正好契合7天的连续旅行这就充分的使用了这张通行证，而且比7张一天有效期的通行证划算

• 要得到整个序列(days[0]到days[days.length-1])的最低消费

• 考虑其中第days[i]天,0<=i<days.length,days[0]<=days[i]<=days[days.length-1],因为day是一个严格升序的序列

• 递归的考虑days[i]+1到days[days.length-1])的最低消费，days[i]+7到days[days.length-1])的最低消费，days[i]+30到days[days.length-1])的最低消费

• 其对应的花费也就是costs[0],costs[1],costs[2],不断计算最优的上一步使用这三种方式总共开销的最小值即是最低消费方式

C/C++题解：

class Solution {

public:

    vector<int> result;

    vector<int> valid = {1, 7, 30};

    int mincostTickets(vector<int>& days, vector<int>& costs) {

        result.resize(days.size());

        return solve(0, days, costs); }//返回整个序列最优值

    int solve(int i,vector<int>& days, vector<int>& costs) {

        if (i >= days.size())//days数组下标不在范围内不计算

            return 0;

        if (result[i] != 0)//把过程中重复计算的直接记下来

            return result[i];//再使用该数值时直接从result数组中取值,体现了记忆的特点

        result[i] = INT_MAX;

        int j = i;

        for (int k = 0; k < 3; k++) {//从顶递归到序列最后，再这一步选择上计算这三种方式

            while (j < days.size() && days[j] < days[i] + valid[k]) j++;

            result[i] = min(result[i], solve(j, days, costs) + costs[k]);//记录最低消费

        }//再不断向前返回下一步这三种消费方式中消费最低的返回给上层，最后回到整个序列

        return result[i];}};

Debug结果：

Java题解：

class Solution {

    public int[] result;

    public int[] valid = new int[]{1, 7, 30};//三种通行证有效期

    public int mincostTickets(int[] days, int[] costs) {

        result = new int[days.length];

        return solve(0, days, costs);}//返回整个序列最优值

    public int solve(int i,int[] days, int[] costs) {

        if (i >= days.length)//days数组下标不在范围内不计算

            return 0;

        if (result[i] != 0)//把过程中重复计算的直接记下来

            return result[i];//再使用该数值时直接从result数组中取值,体现了记忆的特点

        result[i] = Integer.MAX_VALUE;

        int j = i;

        for (int k = 0; k < 3; k++) {//从顶递归到序列最后，再这一步选择上计算这三种方式

            while (j < days.length && days[j] < days[i] + valid[k]) j++;

            result[i] = Math.min(result[i], solve(j, days, costs) + costs[k]);//记录最低消费

        }//再不断向前返回下一步这三种消费方式中消费最低的返回给上层，最后回到整个序列

        return result[i];}}

Debug结果：

Python题解：

class Solution(object):

    def mincostTickets(self, days, costs):

        """:type days: List[int]:type costs: List[int]:rtype: int"""

        result = [0] * len(days)

        valid = [1, 7, 30]

        def solve(i, days, costs) :

            if  i >= len(days):#days数组下标不在范围内不计算

                return 0

            if  result[i] != 0: #把过程中重复计算的直接记下来

                return result[i]#再使用该数值时直接从result数组中取值,体现了记忆的特点

            result[i] = sys.maxint

            j = i

            for k in range(3): #从顶递归到序列最后，再这一步选择上计算这三种方式

                while  j < len(days) and days[j] < days[i] + valid[k]: 

                    j += 1

                result[i] = min(result[i], solve(j, days, costs) + costs[k])#记录最低消费

            #再不断向前返回下一步这三种消费方式中消费最低的返回给上层，最后回到整个序列

            return result[i]

        return solve(0, days, costs) #返回整个序列最优值

Debug结果：

更多题解思想可前往公众号免费获取，获取本文回复“983”