「这是我参与11月更文挑战的第15天，活动详情查看：2021最后一次更文挑战」
1449 数位成本和为目标值的最大数字
题目描述
给你一个整数数组 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"
方法：动态规划
解题思路
1 求满足要求的数的最大位数
位数多的数更大，所以我们先求能满足target的数的最大位数
设dp[i][j]表示前i个数，在总成本为j的条件下能组成的数的最大位数
对于第i个数，其成本为c = cost[i - 1]
若j < c，即成本超出，不能选这个数，则dp[i][j] = dp[i - 1][j]
若j >= c，即可以选择这个数，但选了不一定位数最多，则dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - c] + 1)，即选和不选两种情况取位数大的，因为每个数可以不止选一次，所以选这个数时位数为dp[i][j - c] + 1
最终结果为dp[9][target]，并且设不能得到满足要求的整数时dp[i][j] = -∞
初始化：dp[0][0] = 0，观察转移式，当成本j用完之后，最终都会递推到dp[0][0]，所以初始化为0
其余值均设为-Number.MAX_SAFE_INTEGER
2 加入记录选择路径的数组
设from[i][j]表示dp[i][j]从哪个状态转移而来，即记录其上一时刻的成本值
若dp[i][j] = dp[i - 1][j]，即未选第i个数，则from[i][j] = j
若dp[i][j] = dp[i][j - c] + 1，即选择第i个数，这from[i][j] = j - c
特别地，对于dp[i - 1][j] == dp[i][j - c] + 1，即对于第i个数选与不选最大位数相同时，我们选择这个数，因为第i个数最大
3 倒推得到最大的数
从from[9][target]开始倒推，根据from[i][j]是否等于j，可以知道有没有选第i个数
知道有没有选之后可以推出dp[i][j]的前一个状态是dp[i - 1][j]还是dp[i][j - c] + 1，根据前一个状态判断前一个from是否等于j
依次类推
代码
/**
* @param {number[]} cost
* @param {number} target
* @return {string}
*/
var largestNumber = function(cost, target) {
const dp = new Array(10).fill(0).map(() => new Array(target + 1).fill(-Number.MAX_SAFE_INTEGER))
const from = new Array(10).fill(0).map(() => new Array(target + 1).fill(0))
dp[0][0] = 0
for (let i = 1; i <= 9; i++) {
const c = cost[i - 1]
for (let j = 0; j <= target; j++) {
if (j < c) {
dp[i][j] = dp[i - 1][j]
from[i][j] = j
} else {
if (dp[i - 1][j] > (dp[i][j - c] + 1)) {
dp[i][j] = dp[i - 1][j]
from[i][j] = j
} else {
dp[i][j] = dp[i][j - c] + 1
from[i][j] = j - c
}
}
}
}
if (dp[9][target] < 0) {
return '0'
}
let i = 9
let j = target
const res = []
while (i > 0) {
if (from[i][j] === j) {
i--
} else {
res.push(i)
j = from[i][j]
}
}
return res.join('')
};
算法复杂度分析
- 时间复杂度：O(n * target)，n为cost长度
- 空间复杂度：O(n * target)，n为cost长度
优化
- 观察转移式，
dp[i][j]只与上一行同列数以及同一行前面的数有关，于是使用滚动数组可以去掉数组的第一维度 - 可以去掉
from数组，根据dp[j]是否等于dp[j - c] + 1判断是否选择了第i个数
代码
var largestNumber = function(cost, target) {
const dp = new Array(target + 1).fill(-Number.MAX_SAFE_INTEGER)
dp[0] = 0
for (let i = 1; i <= 9; i++) {
const c = cost[i - 1]
for (let j = c; j <= target; j++) {
dp[j] = Math.max(dp[j], dp[j - c] + 1)
}
}
if (dp[target] < 0) {
return '0'
}
let i = 9
let j = target
const res = []
while (i > 0) {
if (dp[j] !== dp[j - cost[i - 1]] + 1) {
i--
} else {
res.push(i)
j = j - cost[i - 1]
}
}
return res.join('')
};
算法复杂度分析
- 时间复杂度：O(n * target)，n为cost长度
- 空间复杂度：O(target)
