LeetCode1449. 数位成本和为目标值的最大数字（再思考动规中的最多和恰好）

1449. 数位成本和为目标值的最大数字

2021.6.12每日一题

题目描述

给你一个整数数组 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"

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/form-largest-integer-with-digits-that-add-up-to-target
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

基本上算做了一上午，终于做出来了，感觉怎么说呢，没有那种喜悦感，可能费太多时间了，但是还是能学到东西的

刚开始是这样思考的：
首先明确是动态规划，并且一个数能选多次，完全背包
定义dp[i][j]为当前 i 位，称为恰好为 j 的最大整数，状态转移方程也好写
dp[i][j] = max(dp[i - 1][j], 当前值 * 倍数 + dp[i][j - cost[i]])

然后写代码时，发现这个当前倍数不好表示，所以想到从后向前遍历，先把大的数添加到前面，然后用dp[i][j] = max(dp[i - 1][j], dp[i][j- cost[i]] * 10 + i) 这样转移
然后写出了前两天练的二维完全背包的通用代码，运行报错，发现这样写不能保证恰好等于当前成本j

然后就想怎么能使成本恰好等于，想到，初始化时把所有值都赋成一个很小的数，只有j = 0赋值为0，即dp[0] = 0；这样在转移的时候，如果发现前面的转移点是很小的数，那么就不发生转移，因为不能够使得成本恰好等于 j，而0或者其他数可以转移
这个最开始写在一维的里面，执行代码，把开始的几个用例都过了，但是转移到二维，发现不行，研究了一会二维的怎么赋初值，没研究出来就放弃二维了

然后提交，发现[1,1,1,1,1,1,1,3,2] 10 没过，想不太明白，就打出来dp数组看了一下，仔细推导了一下发现越界了，10个7超过了Integer.MAX_VALUE;
然后转用long表示，发现还是越界了

没办法，只能用字符串来判断了，字符串判断的时候，将初始值从一个很小的数变成了“-1”
字符串的比较，1.长度大的数字大 2.长度相同的从左到右看字符大小
然后运行，发现输出数字前面有0，很快想到开始转移的时候，拼接字符串前面有0
注意转移的时候-1的长度，是2，如果不特殊处理，最后结果都会是-1

最终代码如下：

class Solution {
    public String largestNumber(int[] cost, int target) {
        //一看又是动态规划的题
        //dp[i][j]添加到第i位，然后成本为j的最大整数
        //dp[i][j] = max(dp[i - 1][j], res * 10 + dp[i][j - cost[i]])
        //最大值的表示，当前值*10+之前最大值
        //每一个能选多次，完全背包

        String[] dp = new String[target + 1];
        //初始化,dp[i][0] = 0;
        Arrays.fill(dp, "-1");
        dp[0] = "0";
        for(int i = 8; i >= 0; i--) {
            for (int j = cost[i]; j <= target; j++) {
                if(dp[j - cost[i]] != "-1"){
                    StringBuffer sb = new StringBuffer(dp[j - cost[i]]);
                    if(sb.charAt(0) == '0')
                        sb.deleteCharAt(0);
                    sb.append((i + 1) + "");
                    int len = dp[j].length();
                    if(dp[j] == "-1")
                        len = 1;
                    if(sb.length() > len)
                        dp[j] = sb.toString();
                    else if(sb.length() < len)
                        dp[j] = dp[j];
                    else if(dp[j].compareTo(sb.toString()) < 0)
                        dp[j] = sb.toString();
                }                
            }
        }
        if(dp[target] == "-1")
            return "0";
        return String.valueOf(dp[target]);
    }
}

看了下题解，分两步dp，第一步处理长度，第二步再根据长度处理数值，很巧妙，学习了

class Solution {
    public String largestNumber(int[] cost, int t) {
        int[] f = new int[t + 1];
        Arrays.fill(f, Integer.MIN_VALUE);
        f[0] = 0;
        //预先处理处最大的长度
        for (int i = 1; i <= 9; i++) {
            int u = cost[i - 1];
            for (int j = u; j <= t; j++) {
                f[j] = Math.max(f[j], f[j - u] + 1);
            }
        }
        if (f[t] < 0) return "0";
        String ans = "";
        for (int i = 9, j = t; i >= 1; i--) {
            int u = cost[i - 1];
            while (j >= u && f[j] == f[j - u] + 1) {
                ans += String.valueOf(i);
                j -= u;
            }
        }
        return ans;
    }
}

作者：AC_OIer
链接：https://leetcode-cn.com/problems/form-largest-integer-with-digits-that-add-up-to-target/solution/gong-shui-san-xie-fen-liang-bu-kao-lu-we-uy4y/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

这个题继续引发了我对最多和恰好的思考，因为大前天盈利计划那个题，我以为我弄明白最多和恰好的区别了，结果今天这个题又给我弄懵了；然后又回去看了一下那个题，发现那个题之所以能只靠初始值区分最多和恰好，是因为转移的时候，是直接从前面一个数转移来的，而没有什么max，min这种转移限定
而这个题，因为有了这种限定，所以不能只靠初始值来区分，需要特殊处理！！
但是这样想对不对，还是和完全背包有关系，还没有想的太明白！
当然，这只是我现阶段的理解，相信这个动规月会让我完全整明白的！！！！！