Added tasks 514-525.

Author: javadev

README.md

@@ -1571,6 +1571,7 @@
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0005 |[Longest Palindromic Substring](src/main/kotlin/g0001_0100/s0005_longest_palindromic_substring)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Dynamic_Programming | 323 | 75.48
+| 0516 |[Longest Palindromic Subsequence](src/main/kotlin/g0501_0600/s0516_longest_palindromic_subsequence)| Medium | String, Dynamic_Programming | 243 | 87.50
 
 #### Day 18
 
@@ -1592,6 +1593,7 @@
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0322 |[Coin Change](src/main/kotlin/g0301_0400/s0322_coin_change)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Breadth_First_Search | 332 | 50.68
+| 0518 |[Coin Change II](src/main/kotlin/g0501_0600/s0518_coin_change_2)| Medium | Array, Dynamic_Programming | 139 | 100.00
 
 #### Day 21
 
@@ -1613,6 +1615,18 @@
 | 0647 |[Palindromic Substrings](src/main/kotlin/g0601_0700/s0647_palindromic_substrings)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming | 266 | 67.83
 | 0560 |[Subarray Sum Equals K](src/main/kotlin/g0501_0600/s0560_subarray_sum_equals_k)| Medium | Top_100_Liked_Questions, Array, Hash_Table, Prefix_Sum, Data_Structure_II_Day_5_Array | 692 | 53.27
 | 0543 |[Diameter of Binary Tree](src/main/kotlin/g0501_0600/s0543_diameter_of_binary_tree)| Easy | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Level_2_Day_7_Tree, Udemy_Tree_Stack_Queue | 307 | 43.93
+| 0525 |[Contiguous Array](src/main/kotlin/g0501_0600/s0525_contiguous_array)| Medium | Array, Hash_Table, Prefix_Sum | 471 | 100.00
+| 0524 |[Longest Word in Dictionary through Deleting](src/main/kotlin/g0501_0600/s0524_longest_word_in_dictionary_through_deleting)| Medium | Array, String, Sorting, Two_Pointers | 307 | 100.00
+| 0523 |[Continuous Subarray Sum](src/main/kotlin/g0501_0600/s0523_continuous_subarray_sum)| Medium | Array, Hash_Table, Math, Prefix_Sum | 682 | 95.45
+| 0522 |[Longest Uncommon Subsequence II](src/main/kotlin/g0501_0600/s0522_longest_uncommon_subsequence_ii)| Medium | Array, String, Hash_Table, Sorting, Two_Pointers | 163 | 100.00
+| 0521 |[Longest Uncommon Subsequence I](src/main/kotlin/g0501_0600/s0521_longest_uncommon_subsequence_i)| Easy | String | 146 | 88.89
+| 0520 |[Detect Capital](src/main/kotlin/g0501_0600/s0520_detect_capital)| Easy | String | 161 | 84.54
+| 0519 |[Random Flip Matrix](src/main/kotlin/g0501_0600/s0519_random_flip_matrix)| Medium | Hash_Table, Math, Randomized, Reservoir_Sampling | 270 | 100.00
+| 0518 |[Coin Change II](src/main/kotlin/g0501_0600/s0518_coin_change_2)| Medium | Array, Dynamic_Programming, Dynamic_Programming_I_Day_20 | 139 | 100.00
+| 0517 |[Super Washing Machines](src/main/kotlin/g0501_0600/s0517_super_washing_machines)| Hard | Array, Greedy | 210 | 100.00
+| 0516 |[Longest Palindromic Subsequence](src/main/kotlin/g0501_0600/s0516_longest_palindromic_subsequence)| Medium | String, Dynamic_Programming, Dynamic_Programming_I_Day_17 | 243 | 87.50
+| 0515 |[Find Largest Value in Each Tree Row](src/main/kotlin/g0501_0600/s0515_find_largest_value_in_each_tree_row)| Medium | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 238 | 73.33
+| 0514 |[Freedom Trail](src/main/kotlin/g0501_0600/s0514_freedom_trail)| Hard | String, Dynamic_Programming, Depth_First_Search, Breadth_First_Search | 182 | 100.00
 | 0513 |[Find Bottom Left Tree Value](src/main/kotlin/g0501_0600/s0513_find_bottom_left_tree_value)| Medium | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 190 | 88.24
 | 0511 |[Game Play Analysis I](src/main/kotlin/g0501_0600/s0511_game_play_analysis_i)| Easy | LeetCode_Curated_SQL_70, Database, SQL_I_Day_8_Function | 790 | 45.04
 | 0509 |[Fibonacci Number](src/main/kotlin/g0501_0600/s0509_fibonacci_number)| Easy | Dynamic_Programming, Math, Recursion, Memoization, Dynamic_Programming_I_Day_1, Level_1_Day_10_Dynamic_Programming, Udemy_Dynamic_Programming | 139 | 82.72

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

@@ -0,0 +1,83 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 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`.
+
+## Solution
+
+```kotlin
+class Solution {
+    fun findRotateSteps(ring: String, key: String): Int {
+        val indexs: Array<MutableList<Int>?> = arrayOfNulls<MutableList<Int>?>(26)
+        for (i in 0 until ring.length) {
+            val num = ring[i].code - 'a'.code
+            if (indexs[num] == null) {
+                indexs[num] = ArrayList()
+            }
+            indexs[num]!!.add(i)
+        }
+        val dp = Array(101) { IntArray(101) }
+        return find(ring, 0, key, 0, dp, indexs)
+    }
+
+    private fun find(
+        ring: String,
+        i: Int,
+        key: String,
+        j: Int,
+        cache: Array<IntArray>,
+        indexs: Array<MutableList<Int>?>
+    ): Int {
+        if (j == key.length) {
+            return 0
+        }
+        if (cache[i][j] != 0) {
+            return cache[i][j]
+        }
+        var ans = Int.MAX_VALUE
+        val targets: List<Int>? = indexs[key[j].code - 'a'.code]
+        for (t in targets!!) {
+            var 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/kotlin/g0501_0600/s0515_find_largest_value_in_each_tree_row/readme.md

@@ -0,0 +1,71 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 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>
+
+## Solution
+
+```kotlin
+import com_github_leetcode.TreeNode
+import java.util.LinkedList
+import java.util.Queue
+
+/*
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    fun largestValues(root: TreeNode?): List<Int> {
+        val list: MutableList<Int> = ArrayList()
+        val queue: Queue<TreeNode?> = LinkedList()
+        if (root != null) {
+            queue.offer(root)
+            while (!queue.isEmpty()) {
+                var max = Int.MIN_VALUE
+                val size = queue.size
+                for (i in 0 until size) {
+                    val 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/kotlin/g0501_0600/s0516_longest_palindromic_subsequence/readme.md

@@ -0,0 +1,58 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 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.
+
+## Solution
+
+```kotlin
+class Solution {
+    fun longestPalindromeSubseq(s: String): Int {
+        if (s.isEmpty()) {
+            return 0
+        }
+        val dp = Array(s.length) { IntArray(s.length) }
+        for (jidiff in 0 until s.length) {
+            for (i in 0 until s.length) {
+                val j = i + jidiff
+                if (j >= s.length) {
+                    continue
+                }
+                dp[i][j] = when (j) {
+                    i -> 1
+                    i + 1 -> if (s[i] == s[j]) 2 else 1
+                    else -> if (s[i] == s[j]) 2 + dp[i + 1][j - 1] else Math.max(dp[i + 1][j], dp[i][j - 1])
+                }
+            }
+        }
+        return dp[0][s.length - 1]
+    }
+}
+```

src/main/kotlin/g0501_0600/s0517_super_washing_machines/readme.md

@@ -0,0 +1,76 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 517\. Super Washing Machines
+
+Hard
+
+You have `n` super washing machines on a line. Initially, each washing machine has some dresses or is empty.
+
+For each move, you could choose any `m` (`1 <= m <= n`) washing machines, and pass one dress of each washing machine to one of its adjacent washing machines at the same time.
+
+Given an integer array `machines` representing the number of dresses in each washing machine from left to right on the line, return _the minimum number of moves to make all the washing machines have the same number of dresses_. If it is not possible to do it, return `-1`.
+
+**Example 1:**
+
+**Input:** machines = [1,0,5]
+
+**Output:** 3
+
+**Explanation:** 
+
+1st move: 1 0 <-- 5 => 1 1 4 
+
+2nd move: 1 <-- 1 <-- 4 => 2 1 3 
+
+3rd move: 2 1 <-- 3 => 2 2 2
+
+**Example 2:**
+
+**Input:** machines = [0,3,0]
+
+**Output:** 2
+
+**Explanation:** 
+
+1st move: 0 <-- 3 0 => 1 2 0 
+
+2nd move: 1 2 --> 0 => 1 1 1
+
+**Example 3:**
+
+**Input:** machines = [0,2,0]
+
+**Output:** -1
+
+**Explanation:** It's impossible to make all three washing machines have the same number of dresses.
+
+**Constraints:**
+
+*   `n == machines.length`
+*   <code>1 <= n <= 10<sup>4</sup></code>
+*   <code>0 <= machines[i] <= 10<sup>5</sup></code>
+
+## Solution
+
+```kotlin
+class Solution {
+    fun findMinMoves(machines: IntArray): Int {
+        var total = 0
+        for (i in machines) {
+            total += i
+        }
+        if (total % machines.size != 0) {
+            return -1
+        }
+        val avg = total / machines.size
+        var cnt = 0
+        var max = 0
+        for (load in machines) {
+            cnt += load - avg
+            max = Math.max(Math.max(max, Math.abs(cnt)), load - avg)
+        }
+        return max
+    }
+}
+```