一起来做题系列之记忆化搜索

为什么要记忆化搜索

以最低票价这题为例，如果直接搜的话，每次在树形决策分支处可能重复调用，从而有可能超时。

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

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

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

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

https://leetcode-cn.com/problems/minimum-cost-for-tickets

思路

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

在days[i] 处，你有多少种选择？
3种，买1天的、7天的、30天的

memo的作用？
存储memo[i]表示： 在day[i]处，这3种选择最小的花费是多少

结束条件？
当前下标的值>= days数组的长度，代表此时已经没有要规划的一天的，自然花费就为0，返回0即可

/**
 * @param {number[]} days
 * @param {number[]} costs
 * @return {number}
 */
var mincostTickets = function(days, costs) {
    let duration = [1,7,30]

    let memo = {}

    dfs=(cur)=>{
        // 边界条件
        if (cur>=days.length) return 0

        if(memo[cur]) return  memo[cur]

        let i = cur

        // 每一天有3种选择 选3种中花费最小的，并缓存起来
        for(let k=0;k<costs.length;++k){
            // 做完某一种选择后，下一步到规划哪一天了（也就是该处理days的哪一个下标了）
            while (i<days.length&& days[i]<days[cur]+duration[k]){
                i++
            }
            // i之前的天已经规划完毕
            if (!memo[cur]) memo[cur] = Infinity
            
            memo[cur] = Math.min(memo[cur],costs[k]+dfs(i))
        }
        return memo[cur]
    }

    return dfs(0)
};

相似题目：零钱兑换

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。

你可以认为每种硬币的数量是无限的。

示例 1：

输入：coins = [1, 2, 5], amount = 11
输出：3
解释：11 = 5 + 5 + 1

https://leetcode-cn.com/problems/coin-change

思路

可用动态规划，dp[j] 表示凑足数额j，最少需要硬币的个数
那么 dp[j] = min(dp[j-coins[0]], dp[j-coins[1]] , dp[j-coins[2]] )+1
也就是从后往前推，3种面额中那种硬币个数最少
当然 j-coins[i] >=0 其中 0 <=i <=2
dp[0] = 0 边界条件：数额为0时，不需要硬币

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:

        # 动态规划
        # F(amount) = min( F(amount-coins[0]),F(amount-coins[1]) 
        # ,F(amount-coins[1])
        # )+1
        # F（amount）代表凑足amount资金所需的最少硬币个数

        dp = [0]*(amount+1)

        for i  in range(1,amount+1):
            res = float("inf")
            for j in range(len(coins)):
                if (i-coins[j]>=0):
                    res = min(res,dp[i-coins[j]]+1)
            
            dp[i] = res
        if dp[amount]==float("inf"):
            return -1
        return dp[amount]