LeetCode-Python-1449. 数位成本和为目标值的最大数字(记忆化搜索 + DP）

最新推荐文章于 2024-10-11 16:56:17 发布

暴躁老哥在线刷题

最新推荐文章于 2024-10-11 16:56:17 发布

阅读量102

点赞数

文章标签：算法 leetcode python 动态规划

本文链接：https://blog.csdn.net/qq_32424059/article/details/131179976

版权

该问题是一个关于计算最优整数的问题，给定每个数位的成本和一个目标总成本，需要找到能组成最大整数的数位组合，要求总成本等于目标值且不包含0。文章提供了两种解决方案，一种是基于记忆化搜索的方法，另一种是使用动态规划。在找不到符合条件的整数时，返回0。

摘要由CSDN通过智能技术生成

给你一个整数数组 cost 和一个整数 target 。请你返回满足如下规则可以得到的最大整数：

给当前结果添加一个数位（i + 1）的成本为 cost[i] （cost 数组下标从 0 开始）。
总成本必须恰好等于 target 。
添加的数位中没有数字 0 。

由于答案可能会很大，请你以字符串形式返回。

如果按照上述要求无法得到任何整数，请你返回 "0" 。

示例 1：

输入：cost = [4,3,2,5,6,7,2,5,5], target = 9
输出："7772"
解释：添加数位 '7' 的成本为 2 ，添加数位 '2' 的成本为 3 。所以 "7772" 的代价为 2*3+ 3*1 = 9 。 "977" 也是满足要求的数字，但 "7772" 是较大的数字。
 数字     成本
  1  ->   4
  2  ->   3
  3  ->   2
  4  ->   5
  5  ->   6
  6  ->   7
  7  ->   2
  8  ->   5
  9  ->   5

示例 2：

输入：cost = [7,6,5,5,5,6,8,7,8], target = 12
输出："85"
解释：添加数位 '8' 的成本是 7 ，添加数位 '5' 的成本是 5 。"85" 的成本为 7 + 5 = 12 。

示例 3：

输入：cost = [2,4,6,2,4,6,4,4,4], target = 5
输出："0"
解释：总成本是 target 的条件下，无法生成任何整数。

示例 4：

输入：cost = [6,10,15,40,40,40,40,40,40], target = 47
输出："32211"

提示：

cost.length == 9
1 <= cost[i] <= 5000
1 <= target <= 5000

思路：

这道题是套皮的完全背包，让你从 1 - 9 里选数字，每个数字的价值就是 cost 数字，可以重复选，使得你选出来的数字的价值之和等于 target。

第一种实现：

标准记忆化搜索。

我在处理是否完全等于 target 的时候，用了 "#" 表示无效的组合，因为最后组合之和不是 target。

其次字符串的比较需要额外写一个函数。

时空复杂度：O（len(cost) * target)

空间复杂度：O（len(cost) * target)

class Solution:
    def largestNumber(self, cost: List[int], target: int) -> str:
        n = len(cost)

        @cache
        def dfs(i, c):
            if i < 0:
                return "#" if c != 0 else ""
            if c < cost[i]:
                return dfs(i - 1, c)
            else:
                return self.maxString(dfs(i - 1, c), str(i + 1) + dfs(i, c - cost[i]))
        res = dfs(n - 1, target)
        return res if "#" not in res else "0"
    
    def maxString(self, s1, s2):
        if "#" in s1 and "#" in s2:
            return "#"
        if "#" in s1:
            return s2
        if "#" in s2:
            return s1
        
        if len(s1) == len(s2):
            return max(s1, s2)
        elif len(s1) < len(s2):
            return s2
        else:
            return s1

第二种实现：

把记忆化搜索推广到dp。

class Solution:
    def largestNumber(self, cost: List[int], target: int) -> str:
        n = len(cost)
        dp = [["#"] * (target + 1) for _ in range(n + 1)]
        dp[0][0] = ""
        for i in range(n):
            for c in range(target + 1):
                if c < cost[i]:
                    dp[i + 1][c] = dp[i][c]
                else:
                    dp[i + 1][c] = self.maxString(dp[i][c], str(i + 1) + dp[i + 1][c - cost[i]])
        # print(dp)
        return dp[n][target] if "#" not in dp[n][target] else "0"
    
    def maxString(self, s1, s2):
        if "#" in s1 and "#" in s2:
            return "#"
        if "#" in s1:
            return s2
        if "#" in s2:
            return s1
        
        if len(s1) == len(s2):
            return max(s1, s2)
        elif len(s1) < len(s2):
            return s2
        else:
            return s1