From 6b877671dc68126ef97cc98dc2e1d56bda5c1fa9 Mon Sep 17 00:00:00 2001 From: Leo <582717189@qq.com> Date: Fri, 8 Jan 2021 16:08:43 +0800 Subject: [PATCH] 19 --- src/leo/class17/PrintStr.java | 33 ++- .../class17/ReverseStackUsingRecursive.java | 22 +- src/leo/class18/CardsInLine.java | 1 + src/leo/class18/RobotWalk.java | 2 + src/leo/class19/ConvertToLetterString.java | 135 ++++++++++ src/leo/class19/Knapsack.java | 206 ++++++++++++++- src/leo/class19/LongestCommonSubsequence.java | 97 +++++++ src/leo/class19/StickersToSpellWord.java | 236 ++++++++++++++++++ 8 files changed, 729 insertions(+), 3 deletions(-) create mode 100644 src/leo/class19/LongestCommonSubsequence.java diff --git a/src/leo/class17/PrintStr.java b/src/leo/class17/PrintStr.java index e5d7eb0..280dfd5 100644 --- a/src/leo/class17/PrintStr.java +++ b/src/leo/class17/PrintStr.java @@ -118,6 +118,35 @@ public class PrintStr { * 打印一个字符串的全部排列 */ static class Permutations{ + public static String[] permutation(String s) { + + if (s == null || s.length() == 0) { + return new String[]{}; + } + List ans = new ArrayList<>(); + char[] str = s.toCharArray(); + process(str, 0, ans); + return ans.toArray(new String[ans.size()]); + + } + + private static void process(char[] str, int i, List ans) { + if (i == str.length) { + ans.add(String.valueOf(str)); + }else{ + for (int j = i; j < str.length; j++) { + swap(str, i, j); + process(str, i + 1, ans); + swap(str, i, j); + } + } + } + + private static void swap(char[] str, int i, int j) { + char temp = str[i]; + str[i] = str[j]; + str[j] = temp; + } } @@ -169,8 +198,10 @@ public class PrintStr { List subNoRepeat = SubNoRepeat.subNoRepeat(str); System.out.println(subNoRepeat.toString()); - String[] permutation = PermutationsNoRepeat.permutation(str); + String[] permutation = Permutations.permutation(str); + String[] permutationNoRepeat = PermutationsNoRepeat.permutation(str); System.out.println(new ArrayList(Arrays.asList(permutation)).toString()); + System.out.println(new ArrayList(Arrays.asList(permutationNoRepeat)).toString()); } } diff --git a/src/leo/class17/ReverseStackUsingRecursive.java b/src/leo/class17/ReverseStackUsingRecursive.java index 9ce998d..6b77ddd 100644 --- a/src/leo/class17/ReverseStackUsingRecursive.java +++ b/src/leo/class17/ReverseStackUsingRecursive.java @@ -78,7 +78,27 @@ public class ReverseStackUsingRecursive { } } + static class Code3 { + public static void reverse(Stack stack) { + + if (stack.isEmpty()) { + return; + } + Integer last = f(stack); + reverse(stack); + stack.push(last); + } + private static Integer f(Stack stack) { + Integer value = stack.pop(); + if (stack.isEmpty()) { + return value; + } + int last = f(stack); + stack.push(value); + return last; + } + } public static void main(String[] args){ Stack stack = new Stack<>(); @@ -86,7 +106,7 @@ public class ReverseStackUsingRecursive { stack.push(2); stack.push(3); stack.push(4); - Code2.reverse(stack); + Code3.reverse(stack); System.out.println(stack); } diff --git a/src/leo/class18/CardsInLine.java b/src/leo/class18/CardsInLine.java index 6e27a0b..95449ca 100644 --- a/src/leo/class18/CardsInLine.java +++ b/src/leo/class18/CardsInLine.java @@ -8,6 +8,7 @@ import org.w3c.dom.ranges.Range; * @ClassName CardsInLine * @DATE 2021/1/5 11:48 下午 * @Description + * 范围模型 L...R * 给定一个整型数组arr，代表数值不同的纸牌排成一条线， * 玩家A和玩家B依次拿走每张纸牌， * 规定玩家A先拿，玩家B后拿， diff --git a/src/leo/class18/RobotWalk.java b/src/leo/class18/RobotWalk.java index b19fa64..c18ab1a 100644 --- a/src/leo/class18/RobotWalk.java +++ b/src/leo/class18/RobotWalk.java @@ -7,6 +7,8 @@ import java.awt.event.KeyEvent; * @ClassName RobotWalk * @DATE 2021/1/5 4:27 下午 * @Description + * + * 范围模型 * 一个机器人, 从start出发, * 走到aim,在走k步的情况下, * 一共有多少种走法? diff --git a/src/leo/class19/ConvertToLetterString.java b/src/leo/class19/ConvertToLetterString.java index c6d1a79..65b399e 100644 --- a/src/leo/class19/ConvertToLetterString.java +++ b/src/leo/class19/ConvertToLetterString.java @@ -1,10 +1,145 @@ package leo.class19; +import java.time.OffsetDateTime; + /** * @author Leo * @ClassName ConvertToLetterString * @DATE 2021/1/7 5:19 下午 * @Description + * 从左往右的尝试模型1 + * 规定1和A对应、2和B对应、3和C对应... + * 那么一个数字字符串比如"111”就可以转化为: + * "AAA"、"KA"和"AK" + * 给定一个只有数字字符组成的字符串str，返回有多少种转化结果 */ public class ConvertToLetterString { + + static class Recursion { + public static int number(String s) { + if (s.length() == 0 || s == null) { + return 0; + } + return process(0, s.toCharArray()); + } + + private static int process(int i, char[] str) { + if (i == str.length) { + return 1; + } + if (str[i] == '0') { + return 0; + } + //当前位置单转 + int ans = process(i + 1, str); + //入股不越界,当前位置与下一个位置的和<=26,也计入次数,下一个位置从i+2算 + if (i + 1 < str.length && (str[i] - '0') * 10 + (str[i + 1] - '0') <= 26) { + ans += process(i + 2, str); + } + return ans; + } + } + static class Dp { + public static int number(String s) { + if (s == null || s.length() == 0) { + return 0; + } + int n = s.length(); + int[] dp = new int[n + 1]; + dp[n] = 1; + char[] str = s.toCharArray(); + for (int i = n - 1; i >= 0; i--) { + if (str[i] != '0') { + int ans = dp[i + 1]; + //入股不越界,当前位置与下一个位置的和<=26,也计入次数,下一个位置从i+2算 + if (i + 1 < str.length && (str[i] - '0') * 10 + (str[i + 1] - '0') <= 26) { + ans += dp[i + 2]; + } + dp[i] = ans; + } + } + return dp[0]; + + } + } + + static class Recursion1 { + public static int number(String s) { + if (s == null || s.length() == 0) { + + return 0; + } + return process(0, s.toCharArray()); + } + + private static int process(int i, char[] str) { + if (i == str.length) { + return 1; + } + if (str[i] == '0') { + return 0; + } + //不要当前字符 + int ans = process(i + 1, str); + //要当前字符 + if (i + 1 < str.length && (str[i] - '0') * 10 + (str[i + 1] - '0') < 27) { + ans += process(i + 2, str); + } + return ans; + } + } + + static class Dp1 { + public static int number(String s) { + if (s == null || s.length() == 0) { + return 0; + } + int n = s.length(); + int[] dp = new int[n + 1]; + dp[n] = 1; + char[] str = s.toCharArray(); + for (int i = n - 1; i >= 0; i--) { + if (str[i] != '0') { + int ans = dp[i + 1]; + if (i + 1 < str.length && (str[i] - '0') * 10 + (str[i + 1] - '0') < 27) { + ans += dp[i + 2]; + } + dp[i] = ans; + } + + } + return dp[0]; + } + } + + public static void main(String[] args){ + int testTime = 10000; + System.out.println("start"); + int maxStrLength = 100; + for (int i = 0; i < testTime; i++) { + int length = (int) (maxStrLength * Math.random()); + String s = createRandomString(length); + int r = Recursion1.number(s); + int dp = Dp1.number(s); + if (r != dp) { + System.out.println("r = " + r); + System.out.println("dp = " + dp); + break; + } + } + System.out.println("end"); + + + } + + public static String createRandomString(int length) { + if (length == 0) { + return Math.random() < 0.5 ? null : ""; + } + StringBuffer str = new StringBuffer(); + for (int i = 0; i < length; i++) { + str.append((int)(Math.random() * 10)); + } + return str.toString(); + } } diff --git a/src/leo/class19/Knapsack.java b/src/leo/class19/Knapsack.java index 936a275..bb54000 100644 --- a/src/leo/class19/Knapsack.java +++ b/src/leo/class19/Knapsack.java @@ -1,10 +1,214 @@ package leo.class19; +import java.io.BufferedReader; +import java.util.function.IntPredicate; + /** * @author Leo * @ClassName Knapsack * @DATE 2021/1/6 9:43 上午 - * @Description + * @Description 背包问题 + * 范围模型 */ public class Knapsack { + + + static class Recursion { + + /** + * 功能描述 : 在不超重的情况下,能过得到的最大价值 + * @author Leo + * @date 2021/1/7 4:38 下午 + * @param w 货物的重量 + * @param v 货物的价值 + * @param bag 背包的容量 + * @return int + */ + public static int maxValue(int[] w, int[] v, int bag) { + if (w == null || v == null || w.length != v.length || w.length == 0) { + return 0; + } + return process(w, v, 0, bag); + } + + /** + * 功能描述 : 返回最大价值 + * @author Leo + * @date 2021/1/7 4:40 下午 + * @param w 货物的重量 + * @param v 货物的价值 + * @param i 当前考虑到了i号货物 + * @param bag 背包的容量 + * @return int + */ + private static int process(int[] w, int[] v, int i, int bag) { + if (bag < 0) { + return -1; + } + if (i == w.length) { + return 0; + } + //不要当前的货 + int p1 = process(w, v, i + 1, bag); + //要当前的货 + + int next = process(w, v, i + 1, bag - w[i]); + int p2 = 0; + //防止超出bag容量 + if (next != -1) { + p2 = v[i] + next; + } + return Math.max(p1, p2); + } + } + + static class RecursionDP { + public static int maxValue(int[] w, int[] v, int bag) { + if (w == null || v == null || w.length != v.length || w.length == 0) { + return 0; + } + int n = w.length; + int[][] dp = new int[n + 1][bag + 1]; + for (int i = 0; i <= n; i++) { + for (int j = 0; j <= bag; j++) { + dp[i][j] = -1; + } + } + int value = process(w, v, 0, bag, dp); + return value; + + + } + + private static int process(int[] w, int[] v,int i, int bag, int[][] dp) { + + if (bag < 0) { + return -3; + } + if (i == w.length) { + return 0; + } + if (dp[i][bag] != -1) { + return dp[i][bag]; + } + + int ans = 0; + + int p1 = process(w, v, i + 1, bag, dp); + int next = process(w, v, i + 1, bag - w[i], dp); + int p2 = 0; + if (next != -3) { + p2 = v[i] + next; + } + ans = Math.max(p1, p2); + dp[i][bag] = ans; + return ans; + } + } + + static class Dp { + public static int maxValue(int[] w, int[] v, int bag) { + if (w == null || v == null || w.length != v.length || w.length == 0) { + return 0; + } + int n = w.length; + int[][] dp = new int[n + 1][bag + 1]; + for (int i = n - 1; i >= 0; i--) { + for (int rest = 0; rest <= bag; rest++) { + int p1 = dp[i + 1][rest]; + int p2 = rest - w[i] < 0 ? -1 : v[i] + dp[i + 1][rest - w[i]]; + dp[i][rest] = Math.max(p1, p2); + } + } + return dp[0][bag]; + } + } + + static class Recursion1 { + public static int maxValue(int[] w, int[] v, int bag) { + if (w == null || v == null || w.length != v.length || w.length == 0) { + return 0; + } + return process(w, v, 0, bag); + } + + private static int process(int[] w, int[] v, int i, int rest) { + if (rest < 0) { + return -1; + } + if (i == w.length) { + return 0; + } + //不要当前货 + int p1 = process(w, v, i + 1, rest); + //要当前货 + int next = process(w, v, i + 1, rest - w[i]); + int p2 = 0; + if (next != -1) { + p2 = v[i] + next; + } + return Math.max(p1, p2); + + } + } + + static class Dp1 { + public static int maxValue(int[] w, int[] v, int bag) { + if (w == null || v == null || w.length != v.length || w.length == 0) { + return 0; + } + int n = w.length; + int[][] dp = new int[n + 1][bag + 1]; + //int[n] dp == 0; + for (int i = n - 1; i >= 0; i--) { + for (int rest = 0; rest <= bag; rest++) { + int p1 = dp[i + 1][rest]; + int p2 = rest - w[i] < 0 ? -1 : v[i] + dp[i + 1][rest - w[i]]; + dp[i][rest] = Math.max(p1, p2); + } + } + return dp[0][bag]; + + } + } + + public static void main(String[] args) { + + int maxSize = 20; + int range = 30; + int maxBag = 30; + int testTime = 1000; + System.out.println("start"); + for (int i = 0; i < testTime; i++) { + int size = (int) (maxSize * Math.random()); + int bag = (int) (maxBag * Math.random()); + int[] weights = createRandomArray(size, range); + int[] values = createRandomArray(size, range); + int r = Recursion1.maxValue(weights, values, bag); + int rDp = RecursionDP.maxValue(weights, values, bag); + int dp = Dp1.maxValue(weights, values, bag); + if (r != rDp || rDp != dp || r != dp) { + System.out.println("r = " + r); + System.out.println("rDp = " + rDp); + System.out.println("dp = " + dp); + break; + } + } + System.out.println("end"); + + } + + + public static int[] createRandomArray(int size, int range) { + if (size == 0) { + return null; + } + int[] arr = new int[size]; + for (int i = 0; i < arr.length; i++) { + arr[i] = (int) (range * Math.random()); + } + return arr; + } + + } diff --git a/src/leo/class19/LongestCommonSubsequence.java b/src/leo/class19/LongestCommonSubsequence.java new file mode 100644 index 0000000..ede7826 --- /dev/null +++ b/src/leo/class19/LongestCommonSubsequence.java @@ -0,0 +1,97 @@ +package leo.class19; + +/** + * @author Leo + * @ClassName LongestCommonSubsequence + * @DATE 2021/1/8 1:57 下午 + * @Description + * 样本对应模型 + * 样本对应模型,只讨论当前的结尾如何组织可能性 + * + * 给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。 + * 一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。 + * 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。 + * 若这两个字符串没有公共子序列，则返回 0。 + * + * 链接：https://leetcode-cn.com/problems/longest-common-subsequence + */ +public class LongestCommonSubsequence { + + static class Recursion { + public static int longestCommonSubsequence(String s1, String s2) { + if (s1 == null || s2 == null || s1.length() == 0 || s2.length() == 0) { + return 0; + } + char[] c1 = s1.toCharArray(); + char[] c2 = s2.toCharArray(); + //尝试 + return process(c1, c2, c1.length - 1, c2.length - 1); + } + + /** + * 功能描述 : c1[0...i]与c2[0...j] 的最长公共子序列多少 + * @author Leo + * @date 2021/1/8 3:14 下午 + * @param c1 + * @param c2 + * @param i c1下标 + * @param j c2下标 + * @return int + */ + public static int process(char[] c1, char[] c2, int i, int j) { + if (i == 0 && j == 0) { + return c1[0] == c2[0] ? 1 : 0; + } else if (i == 0) { + if (c1[i] == c2[j]) { + return 1; + }else{ + return process(c1, c2, i, j - 1); + } + } else if (j == 0) { + if (c1[i] == c2[j]) { + return 1; + }else { + return process(c1, c2, i - 1, j); + } + }else { + //i!=0&&j!=0 + //可能考虑j + int p1 = process(c1, c2, i - 1, j); + //可能考虑i + int p2 = process(c1, c2, i, j - 1); + //如果两边相等,不考虑i和j + int p3 = c1[i] == c2[j] ? 1 + process(c1, c2, i - 1, j - 1) : 0; + return Math.max(p1, Math.max(p2, p3)); + } + } + } + + static class Dp { + public static int longestCommonSubsequence(String s1, String s2) { + if (s1 == null || s2 == null || s1.length() == 0 || s2.length() == 0) { + return 0; + } + char[] c1 = s1.toCharArray(); + char[] c2 = s2.toCharArray(); + int n = c1.length; + int m = c2.length; + int[][] dp = new int[n][m]; + dp[0][0] = c1[0] == c2[0] ? 1 : 0; + for (int j = 1; j < c2.length; j++) { + dp[0][j] = c1[0] == c2[j] ? 1 : dp[0][j - 1]; + } + for (int i = 1; i < c1.length; i++) { + dp[i][0] = c1[i] == c2[0] ? 1 : dp[i - 1][0]; + } + for (int i = 1; i < n; i++) { + for (int j = 1; j < m; j++) { + int p1 = dp[i - 1][j]; + int p2 = dp[i][j - 1]; + int p3 = c1[i] == c2[j] ? 1 + dp[i - 1][j - 1] : 0; + dp[i][j] = Math.max(p1, Math.max(p2, p3)); + } + } + return dp[n - 1][m - 1]; + } + } +} diff --git a/src/leo/class19/StickersToSpellWord.java b/src/leo/class19/StickersToSpellWord.java index 775462d..af6ca04 100644 --- a/src/leo/class19/StickersToSpellWord.java +++ b/src/leo/class19/StickersToSpellWord.java @@ -1,10 +1,246 @@ package leo.class19; +import java.util.HashMap; +import java.util.Map; + /** * @author Leo * @ClassName StickersToSpellWord * @DATE 2021/1/7 5:52 下午 * @Description + * 本题测试链接：https://leetcode.com/problems/stickers-to-spell-word + * 给定一个字符串str，给定一个字符串类型的数组arr。 + * arr里的每一个字符串，代表一张贴纸，你可以把单个字符剪开使用，目的是拼出str来。 + * 返回需要至少多少张贴纸可以完成这个任务。 + * 例子：str= "babac"，arr = {"ba","c","abcd"} + * 至少需要两张贴纸"ba"和"abcd"，因为使用这两张贴纸，把每一个字符单独剪开，含有2个a、2个b、1个c。是可以拼出str的。所以返回2。 */ public class StickersToSpellWord { + + static class Recursion { + public static int minStickers(String[] stickers, String target) { + if (stickers == null || stickers.length == 0) { + return -1; + } + int ans = process(stickers, target); + return ans == Integer.MAX_VALUE ? -1 : ans; + } + + /** + * 功能描述 : + * @author Leo + * @date 2021/1/8 10:40 上午 + * @param stickers 贴纸 + * @param target 剩余目标 + * @throw + * @return int + */ + private static int process(String[] stickers, String target) { + if (target.length() == 0) { + return 0; + } + int min = Integer.MAX_VALUE; + for (String sticker : stickers) { + String rest = minus(sticker, target); + //rest 剩余目标 + //如果剩余目标长度不等于目标长度,代表匹配成功了,继续匹配剩余的目标 + if (rest.length() != target.length()) { + //如果没有有效解,会返回MAX_VALUE + min = Math.min(min, process(stickers, rest)); + } + } + return min + (min == Integer.MAX_VALUE ? 0 : 1); + } + + private static String minus(String sticker, String target) { + char[] s = sticker.toCharArray(); + char[] t = target.toCharArray(); + int[] count = new int[26]; + for (int i = 0; i < s.length; i++) { + count[s[i] - 'a']++; + } + for (int i = 0; i < t.length; i++) { + count[t[i] - 'a']--; + } + StringBuffer sb = new StringBuffer(); + for (int i = 0; i < count.length; i++) { + if (count[i] > 0) { + for (int j = 0; j < count[i]; j++) { + sb.append((char) (i + 'a')); + } + } + } + return sb.toString(); + } + } + + static class DpZuo { + public static int minStickers(String[] stickers, String target) { + int N = stickers.length; + // 关键优化(用词频表替代贴纸数组) + int[][] counts = new int[N][26]; + for (int i = 0; i < N; i++) { + char[] str = stickers[i].toCharArray(); + for (char cha : str) { + counts[i][cha - 'a']++; + } + } + int ans = process(counts, target); + return ans == Integer.MAX_VALUE ? -1 : ans; + } + + // stickers[i] 数组，当初i号贴纸的字符统计 int[][] stickers -> 所有的贴纸 + // 每一种贴纸都有无穷张 + // 返回搞定target的最少张数 + // 最少张数 + public static int process(int[][] stickers, String t) { + if (t.length() == 0) { + return 0; + } + // target做出词频统计 + // target aabbc 2 2 1.. + // 0 1 2.. + char[] target = t.toCharArray(); + int[] tcounts = new int[26]; + for (char cha : target) { + tcounts[cha - 'a']++; + } + int N = stickers.length; + int min = Integer.MAX_VALUE; + for (int i = 0; i < N; i++) { + // 尝试第一张贴纸是谁 + int[] sticker = stickers[i]; + // 最关键的优化(重要的剪枝!这一步也是贪心!) + if (sticker[target[0] - 'a'] > 0) { + StringBuilder builder = new StringBuilder(); + for (int j = 0; j < 26; j++) { + if (tcounts[j] > 0) { + int nums = tcounts[j] - sticker[j]; + for (int k = 0; k < nums; k++) { + builder.append((char) (j + 'a')); + } + } + } + String rest = builder.toString(); + min = Math.min(min, process(stickers, rest)); + } + } + return min + (min == Integer.MAX_VALUE ? 0 : 1); + } + } + static class Dp { + public static int minStickers(String[] stickers, String target) { + + int n = stickers.length; + int[][] count = new int[n][26]; + for (int i = 0; i < count.length; i++) { + char[] chars = stickers[i].toCharArray(); + for (char c : chars) { + count[i][c - 'a']++; + } + } + HashMap dp = new HashMap<>(); + dp.put("", 0); + int ans = process(count, target,dp); + return ans == Integer.MAX_VALUE ? -1 : ans; + + } + + private static int process(int[][] stickers, String target, HashMap dp) { + if (dp.containsKey(target)){ + return dp.get(target); + } + if (target.length() == 0) { + return 0; + } + int min = Integer.MAX_VALUE; + //target词频统计 + char[] t = target.toCharArray(); + int[] tCount = new int[26]; + for (char c : t) { + tCount[c - 'a']++; + } + for (int i = 0; i < stickers.length; i++) { + //第i号纸条 + int[] sticker = stickers[i]; + //通过target第一个字符比对,需要哪些贴纸(剪枝,贪心) + if (sticker[t[0] - 'a'] > 0) { + StringBuffer sb = new StringBuffer(); + //开始判断需要的纸条,以及剩下的target + for (int j = 0; j < 26; j++) { + int num = tCount[j] - sticker[j]; + for (int k = 0; k < num; k++) { + sb.append((char) (j + 'a')); + } + } + String restTarget = sb.toString(); + min = Math.min(min, process(stickers, restTarget, dp)); + + } + } + int ans = min + (min == Integer.MAX_VALUE ? 0 : 1); + dp.put(target, ans); + return ans; + } + } + + static class Dp1{ + public static int minStickers(String[] stickers, String target) { + int n = stickers.length; + int[][] count = new int[n][26]; + + for (int i = 0; i < n; i++) { + char[] chars = stickers[i].toCharArray(); + for (char c : chars) { + count[i][c - 'a']++; + } + } + Map dp = new HashMap<>(); + dp.put("", 0); + int ans = process(count, target, dp); + return ans == Integer.MAX_VALUE ? -1 : ans; + } + + private static int process(int[][] stickers, String target, Map dp) { + if (dp.containsKey(target)) { + return dp.get(target); + } + if (target.length() == 0) { + return 0; + } + char[] t = target.toCharArray(); + //统计target词频 + int[] tCount = new int[26]; + for (char c : t) { + tCount[c - 'a']++; + } + int min = Integer.MAX_VALUE; + for (int i = 0; i < stickers.length; i++) { + int[] sticker = stickers[i]; + if (sticker[t[0] - 'a'] > 0) { + StringBuffer sb = new StringBuffer(); + for (int j = 0; j < 26; j++) { + int num = tCount[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, dp)); + } + } + min += min == Integer.MAX_VALUE ? 0 : 1; + dp.put(target, min); + return min; + } + } + + public static void main(String[] args){ + + String[] stickers = {"heavy", "claim", "seven", "set", "had", "it", "dead", "jump", "design", "question", "sugar", "dress", "any", "special", "ground", "huge", "use", "busy", "prove", "there", "lone", "window", "trip", "also", "hot", "choose", "tie", "several", "be", "that", "corn", "after", "excite", "insect", "cat", "cook", "glad", "like", "wont", "gray", "especially", "level", "when", "cover", "ocean", "try", "clean", "property", "root", "wing"}; + String target = "travelbell"; + System.out.println(Dp.minStickers(stickers, target)); + System.out.println(Dp1.minStickers(stickers, target)); + + } }