leetcode691. 贴纸拼词(java)

leetcode691. 贴纸拼词

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/stickers-to-spell-word

题目描述

我们有 n 种不同的贴纸。每个贴纸上都有一个小写的英文单词。
您想要拼写出给定的字符串 target ，方法是从收集的贴纸中切割单个字母并重新排列它们。如果你愿意，你可以多次使用每个贴纸，每个贴纸的数量是无限的。
返回你需要拼出 target 的最小贴纸数量。如果任务不可能，则返回 -1 。
注意：在所有的测试用例中，所有的单词都是从 1000 个最常见的美国英语单词中随机选择的，并且 target 被选择为两个随机单词的连接。

示例 1：
输入： stickers = [“with”,“example”,“science”], target = “thehat”
输出：3
解释：
我们可以使用 2 个 “with” 贴纸，和 1 个 “example” 贴纸。
把贴纸上的字母剪下来并重新排列后，就可以形成目标 “thehat“ 了。
此外，这是形成目标字符串所需的最小贴纸数量。

示例 2:
输入：stickers = [“notice”,“possible”], target = “basicbasic”
输出：-1
解释：我们不能通过剪切给定贴纸的字母来形成目标“basicbasic”。

提示:
n == stickers.length
1 <= n <= 50
1 <= stickers[i].length <= 10
1 <= target.length <= 15
stickers[i] 和 target 由小写英文单词组成

暴力递归

解题思路

stickers 每次取出一个单词，我们用target 减去这个单词，把剩下的继续进行递归，
然后每次递归后，我们取最小值就行了。

代码演示：

 public int minStickers(String[] stickers, String target) {
        int num = process(stickers,target);
        return num == Integer.MIN_VALUE ? -1 : num;
    }

    /**
     * 暴力递归
     * @param stickers
     * @param target
     * @return
     */
    public static int process(String[] stickers, String target){
        //base case 目标单词拼完了，返回0
        if (target.length() == 0){
            return 0;
        }
        int min = Integer.MAX_VALUE;
        for (String str : stickers){
            //每次取出一个单词，和目标单词进行相减，剩下的继续递归
            String res = delete(target, str);
            //判断有没有减掉，减掉再进行递归，
            if (res.length() != target.length()){
                min = Math.min(min,process(stickers,res));
            }
        }
        return min + (min == Integer.MAX_VALUE ? 0 : 1);
    }

    /**
     * 从目标单词中 减去卡片中出现的字符
     * @param target
     * @param str
     * @return
     */
    public static String delete(String target,String str){
        char[] tt = target.toCharArray();
        char[] st = str.toCharArray();
        int[] count = new int[26];
        for (char t : tt){
            count[t - 'a']++;
        }
        for (char s : st){
            count[s - 'a']--;
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 26;i++){
            if (count[i] > 0){
                for (int j = 0; j < count[i];j++){
                    sb.append((char)(i + 'a'));
                }
            }
        }
        return sb.toString();
    }

优化暴力递归

我们用int[] 数组来表示单词，int[0] = 3,就代表单词a 出现三次，这样就可以把stickers 变成一个二维数组，这样再进行减字符操作时，会有很大的提升，

代码演示：

    /**
     * 暴力递归的优化版本
     * @param stickers
     * @param target
     * @return
     */
    public static int minStickers2(String[] stickers, String target) {
        if (stickers == null || stickers.length == 0 || target == null || target.length() == 0){
            return 0;
        }
        int N = stickers.length;
        int[][] count = new int[N][26];
        for (int i = 0; i < N; i++){
            char[] chars1 = stickers[i].toCharArray();
            for (char c : chars1){
                count[i][c - 'a']++;
            }
        }
        int process = process(count, target);
        return process == Integer.MAX_VALUE ? -1 : process;
    }

    /**
     * 用int 二维数组来表示单词，用于优化减字符的操作。
     * @param stickers
     * @param target
     * @return
     */
    public static int process(int[][]stickers,String target){
        if (target.length() == 0){
            return 0;
        }
        char[] chars = target.toCharArray();
        int[] tc = new int[26];
        for (char c : chars){
            tc[c - 'a']++;
        }
        int N = stickers.length;
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < N ;i++){
            int[] sticker = stickers[i];
            //判断包含第一个字符不，不包含就进行下一个单词。贪心操作
            if (sticker[chars[0] - 'a'] > 0){
                StringBuilder sb = new StringBuilder();
                for (int j = 0;j < 26;j++){
                    if (tc[j] > 0){
                        int num = tc[j] - sticker[j];
                        for (int k = 0; k < num;k++){
                            sb.append((char)(j + 'a'));
                        }
                    }
                }
                String rest = sb.toString();
                min = Math.min(min,process(stickers,rest));
            }
        }
        return min + (min == Integer.MAX_VALUE ? 0 : 1);
    }

递归加缓存

在优化的递归上，加个缓存，这样才能保证leetcode 上能跑过去，

代码演示

   /**
     * 暴力递归的优化版本
     * @param stickers
     * @param target
     * @return
     */
    public static int minStickers3(String[] stickers, String target) {
        if (stickers == null || stickers.length == 0 || target == null || target.length() == 0){
            return 0;
        }
        int N = stickers.length;
        int[][] count = new int[N][26];
        for (int i = 0; i < N; i++){
            char[] chars1 = stickers[i].toCharArray();
            for (char c : chars1){
                count[i][c - 'a']++;
            }
        }
        HashMap<String, Integer> dp = new HashMap<>();
        dp.put("",0);
        int process = process2(count, target,dp);
        return process == Integer.MAX_VALUE ? -1 : process;
    }

    /**
     * 加缓存
     * @param stickers
     * @param target
     * @param dp 缓存
     * @return
     */
    public static int process2(int[][]stickers, String target, HashMap<String,Integer>dp){
        //先从缓存中拿
        if(dp.containsKey(target)){
            return dp.get(target);
        }
        if (target.length() == 0){
            return 0;
        }
        char[] chars = target.toCharArray();
        int[] tc = new int[26];
        for (char c : chars){
            tc[c - 'a']++;
        }
        int N = stickers.length;
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < N ;i++){
            int[] sticker = stickers[i];
            if (sticker[chars[0] - 'a'] > 0){
                StringBuilder sb = new StringBuilder();
                for (int j = 0;j < 26;j++){
                    if (tc[j] > 0){
                        int num = tc[j] - sticker[j];
                        for (int k = 0; k < num;k++){
                            sb.append((char)(j + 'a'));
                        }
                    }
                }
                String rest = sb.toString();
                min = Math.min(min,process2(stickers,rest,dp));
            }
        }
        int ans = min + (min == Integer.MAX_VALUE ? 0 : 1);
        //结果保存到缓存中
        dp.put(target,ans);
        return ans;
    }

动态规划专题

背包问题–填满背包的最大价格

leetcode.486. 预测赢家,动态规划

leetcode1143. 最长公共子序列