Added tasks 514, 515, 516

src/main/java/g0501_0600/s0514_freedom_trail/Solution.java

@@ -0,0 +1,39 @@
+package g0501_0600.s0514_freedom_trail;
+
+// #Hard #String #Dynamic_Programming #Depth_First_Search #Breadth_First_Search
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+ public int findRotateSteps(String ring, String key) {
+ List<Integer>[] indexs = new List[26];
+ for (int i = 0; i < ring.length(); i++) {
+ int num = ring.charAt(i) - 'a';
+ if (indexs[num] == null) {
+ indexs[num] = new ArrayList<>();
+ }
+ indexs[num].add(i);
+ }
+ int[][] dp = new int[101][101];
+ return find(ring, 0, key, 0, dp, indexs);
+ }
+
+ private int find(String ring, int i, String key, int j, int[][] cache, List<Integer>[] indexs) {
+ if (j == key.length()) {
+ return 0;
+ }
+ if (cache[i][j] != 0) {
+ return cache[i][j];
+ }
+ int ans = Integer.MAX_VALUE;
+ List<Integer> targets = indexs[key.charAt(j) - 'a'];
+ for (int t : targets) {
+ int delta = Math.abs(i - t);
+ delta = Math.min(delta, Math.abs(ring.length() - delta));
+ ans = Math.min(ans, 1 + delta + find(ring, t, key, j + 1, cache, indexs));
+ }
+ cache[i][j] = ans;
+ return ans;
+ }
+}

src/main/java/g0501_0600/s0514_freedom_trail/readme.md

@@ -0,0 +1,36 @@
+514\. Freedom Trail
+
+Hard
+
+In the video game Fallout 4, the quest **"Road to Freedom"** requires players to reach a metal dial called the **"Freedom Trail Ring"** and use the dial to spell a specific keyword to open the door.
+
+Given a string `ring` that represents the code engraved on the outer ring and another string `key` that represents the keyword that needs to be spelled, return _the minimum number of steps to spell all the characters in the keyword_.
+
+Initially, the first character of the ring is aligned at the `"12:00"` direction. You should spell all the characters in `key` one by one by rotating `ring` clockwise or anticlockwise to make each character of the string key aligned at the `"12:00"` direction and then by pressing the center button.
+
+At the stage of rotating the ring to spell the key character `key[i]`:
+
+1. You can rotate the ring clockwise or anticlockwise by one place, which counts as **one step**. The final purpose of the rotation is to align one of `ring`'s characters at the `"12:00"` direction, where this character must equal `key[i]`.
+2. If the character `key[i]` has been aligned at the `"12:00"` direction, press the center button to spell, which also counts as **one step**. After the pressing, you could begin to spell the next character in the key (next stage). Otherwise, you have finished all the spelling.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/10/22/ring.jpg)
+
+**Input:** ring = "godding", key = "gd"
+
+**Output:** 4
+
+**Explanation:** For the first key character 'g', since it is already in place, we just need 1 step to spell this character. For the second key character 'd', we need to rotate the ring "godding" anticlockwise by two steps to make it become "ddinggo". Also, we need 1 more step for spelling. So the final output is 4.
+
+**Example 2:**
+
+**Input:** ring = "godding", key = "godding"
+
+**Output:** 13
+
+**Constraints:**
+
+* `1 <= ring.length, key.length <= 100`
+* `ring` and `key` consist of only lower case English letters.
+* It is guaranteed that `key` could always be spelled by rotating `ring`.

src/main/java/g0501_0600/s0515_find_largest_value_in_each_tree_row/Solution.java

@@ -0,0 +1,35 @@
+package g0501_0600.s0515_find_largest_value_in_each_tree_row;
+
+// #Medium #Depth_First_Search #Breadth_First_Search #Tree #Binary_Tree
+
+import com_github_leetcode.TreeNode;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class Solution {
+ public List<Integer> largestValues(TreeNode root) {
+ List<Integer> list = new ArrayList<>();
+ Queue<TreeNode> queue = new LinkedList<>();
+ if (root != null) {
+ queue.offer(root);
+ while (!queue.isEmpty()) {
+ int max = Integer.MIN_VALUE;
+ int size = queue.size();
+ for (int i = 0; i < size; i++) {
+ TreeNode curr = queue.poll();
+ max = Math.max(max, curr.val);
+ if (curr.left != null) {
+ queue.offer(curr.left);
+ }
+ if (curr.right != null) {
+ queue.offer(curr.right);
+ }
+ }
+ list.add(max);
+ }
+ }
+ return list;
+ }
+}

src/main/java/g0501_0600/s0515_find_largest_value_in_each_tree_row/readme.md

@@ -0,0 +1,24 @@
+515\. Find Largest Value in Each Tree Row
+
+Medium
+
+Given the `root` of a binary tree, return _an array of the largest value in each row_ of the tree **(0-indexed)**.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/08/21/largest_e1.jpg)
+
+**Input:** root = [1,3,2,5,3,null,9]
+
+**Output:** [1,3,9]
+
+**Example 2:**
+
+**Input:** root = [1,2,3]
+
+**Output:** [1,3]
+
+**Constraints:**
+
+* The number of nodes in the tree will be in the range <code>[0, 10<sup>4</sup>]</code>.
+* <code>-2<sup>31</sup> <= Node.val <= 2<sup>31</sup> - 1</code>

src/main/java/g0501_0600/s0516_longest_palindromic_subsequence/Solution.java

@@ -0,0 +1,26 @@
+package g0501_0600.s0516_longest_palindromic_subsequence;
+
+// #Medium #String #Dynamic_Programming
+
+public class Solution {
+ public int longestPalindromeSubseq(String s) {
+ char[] x = s.toCharArray();
+ char[] y = new StringBuilder(s).reverse().toString().toCharArray();
+ int m = x.length;
+ int n = y.length;
+ int[][] l = new int[m + 1][n + 1];
+ for (int i = 0; i <= m; i++) {
+ for (int j = 0; j <= n; j++) {
+ if (i == 0 || j == 0) {
+ l[i][j] = 0;
+ } else if (x[i - 1] == y[j - 1]) {
+ l[i][j] = l[i - 1][j - 1] + 1;
+
+ } else {
+ l[i][j] = Math.max(l[i - 1][j], l[i][j - 1]);
+ }
+ }
+ }
+ return l[m][n];
+ }
+}

src/main/java/g0501_0600/s0516_longest_palindromic_subsequence/readme.md

@@ -0,0 +1,28 @@
+516\. Longest Palindromic Subsequence
+
+Medium
+
+Given a string `s`, find _the longest palindromic **subsequence**'s length in_ `s`.
+
+A **subsequence** is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.
+
+**Example 1:**
+
+**Input:** s = "bbbab"
+
+**Output:** 4
+
+**Explanation:** One possible longest palindromic subsequence is "bbbb".
+
+**Example 2:**
+
+**Input:** s = "cbbd"
+
+**Output:** 2
+
+**Explanation:** One possible longest palindromic subsequence is "bb".
+
+**Constraints:**
+
+* `1 <= s.length <= 1000`
+* `s` consists only of lowercase English letters.

src/test/java/g0501_0600/s0514_freedom_trail/SolutionTest.java

@@ -0,0 +1,18 @@
+package g0501_0600.s0514_freedom_trail;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void findRotateSteps() {
+ assertThat(new Solution().findRotateSteps("godding", "gd"), equalTo(4));
+ }
+
+ @Test
+ void findRotateSteps2() {
+ assertThat(new Solution().findRotateSteps("godding", "godding"), equalTo(13));
+ }
+}

src/test/java/g0501_0600/s0515_find_largest_value_in_each_tree_row/SolutionTest.java

@@ -0,0 +1,30 @@
+package g0501_0600.s0515_find_largest_value_in_each_tree_row;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com_github_leetcode.TreeNode;
+import com_github_leetcode.TreeUtils;
+import java.util.ArrayList;
+import java.util.Arrays;
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void largestValues() {
+ TreeNode treeNode =
+ TreeUtils.constructBinaryTree(
+ new ArrayList<>(Arrays.asList(1, 3, 2, 5, 3, null, 9)));
+ assertThat(
+ new Solution().largestValues(treeNode),
+ equalTo(new ArrayList<>(Arrays.asList(1, 3, 9))));
+ }
+
+ @Test
+ void largestValues2() {
+ TreeNode treeNode = TreeUtils.constructBinaryTree(new ArrayList<>(Arrays.asList(1, 2, 3)));
+ assertThat(
+ new Solution().largestValues(treeNode),
+ equalTo(new ArrayList<>(Arrays.asList(1, 3))));
+ }
+}

src/test/java/g0501_0600/s0516_longest_palindromic_subsequence/SolutionTest.java

@@ -0,0 +1,18 @@
+package g0501_0600.s0516_longest_palindromic_subsequence;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void longestPalindromeSubseq() {
+ assertThat(new Solution().longestPalindromeSubseq("bbbab"), equalTo(4));
+ }
+
+ @Test
+ void longestPalindromeSubseq2() {
+ assertThat(new Solution().longestPalindromeSubseq("cbbd"), equalTo(2));
+ }
+}