Improved tasks 112, 115, 116, 117, 120, 126

Author: javadev

src.save/main/kotlin/g0101_0200/s0112_path_sum/Solution.kt

@@ -16,12 +16,12 @@ import com_github_leetcode.TreeNode
  * }
  */
 class Solution {
-    fun hasPathSum(root: TreeNode?, sum: Int): Boolean {
+    fun hasPathSum(root: TreeNode?, targetSum: Int): Boolean {
         if (root == null) {
             return false
         }
-        return if (sum == root.`val` && root.left == null && root.right == null) {
+        return if (targetSum == root.`val` && root.left == null && root.right == null) {
             true
-        } else hasPathSum(root.left, sum - root.`val`) || hasPathSum(root.right, sum - root.`val`)
+        } else hasPathSum(root.left, targetSum - root.`val`) || hasPathSum(root.right, targetSum - root.`val`)
     }
 }

src.save/main/kotlin/g0101_0200/s0115_distinct_subsequences/Solution.kt

@@ -3,23 +3,23 @@ package g0101_0200.s0115_distinct_subsequences
 // #Hard #String #Dynamic_Programming #2022_09_29_Time_285_ms_(88.89%)_Space_34.2_MB_(100.00%)
 
 class Solution {
-    fun numDistinct(text: String, text2: String): Int {
-        if (text.length < text2.length) {
+    fun numDistinct(s: String, t: String): Int {
+        if (s.length < t.length) {
             return 0
         }
-        if (text.length == text2.length) {
-            return if (text == text2) 1 else 0
+        if (s.length == t.length) {
+            return if (s == t) 1 else 0
         }
-        val move = text.length - text2.length + 2
+        val move = s.length - t.length + 2
         // Only finite number of character in s can occupy first position in T. Same applies for
         // every character in T.
         val dp = IntArray(move)
         var j = 1
         var k = 1
-        for (i in 0 until text2.length) {
+        for (i in 0 until t.length) {
             var firstMatch = true
             while (j < move) {
-                if (text2[i] == text[i + j - 1]) {
+                if (t[i] == s[i + j - 1]) {
                     if (firstMatch) {
                         // Keep track of first match. To avoid useless comparisons on next
                         // iteration.

src.save/main/kotlin/g0101_0200/s0116_populating_next_right_pointers_in_each_node/Solution.kt

@@ -14,7 +14,6 @@ import com_github_leetcode.left_right.Node
  *     var next: Node? = null
  * }
  */
-
 class Solution {
     fun connect(root: Node?): Node? {
         if (root == null) {

src.save/main/kotlin/g0101_0200/s0117_populating_next_right_pointers_in_each_node_ii/Solution.kt

@@ -18,32 +18,23 @@ import java.util.Queue
  */
 class Solution {
     fun connect(root: Node?): Node? {
-
         if (root == null) return null
-
         val bfsQueue: Queue<Node> = LinkedList()
-
         bfsQueue.offer(root)
         root.next = null
-
         var temp: Node?
         var prev: Node?
-
         while (!bfsQueue.isEmpty()) {
-
             val size = bfsQueue.size
             prev = null
-
             for (j in 0 until size) {
-
                 temp = bfsQueue.poll()
                 if (prev != null) prev.next = temp
                 if (temp!!.left != null) bfsQueue.offer(temp.left)
                 if (temp.right != null) bfsQueue.offer(temp.right)
                 prev = temp
             }
         }
-
         return root
     }
 }

src.save/main/kotlin/g0101_0200/s0120_triangle/Solution.kt

@@ -7,8 +7,8 @@ package g0101_0200.s0120_triangle
 import java.util.Arrays
 
 class Solution {
-    fun minimumTotal(triangle: List<List<Int>>?): Int {
-        if (triangle == null || triangle.isEmpty()) {
+    fun minimumTotal(triangle: List<List<Int>>): Int {
+        if (triangle.isEmpty()) {
             return 0
         }
         val dp = Array(triangle.size) { IntArray(triangle[triangle.size - 1].size) }

src.save/main/kotlin/g0101_0200/s0126_word_ladder_ii/Solution.kt

@@ -8,8 +8,8 @@ import java.util.LinkedList
 import java.util.Queue
 
 class Solution {
-    fun findLadders(beginWord: String, endWord: String, wordList: List<String>?): List<List<String?>> {
-        val ans: MutableList<List<String?>> = ArrayList()
+    fun findLadders(beginWord: String, endWord: String, wordList: List<String>): List<List<String>> {
+        val ans: MutableList<List<String>> = ArrayList()
         // reverse graph start from endWord
         val reverse: MutableMap<String, MutableSet<String>> = HashMap()
         // remove the duplicate words
@@ -59,7 +59,7 @@ class Solution {
         if (!findEnd) {
             return ans
         }
-        val path: MutableSet<String?> = LinkedHashSet()
+        val path: MutableSet<String> = LinkedHashSet()
         path.add(endWord)
         // traverse reverse graph from endWord to beginWord
         findPath(endWord, beginWord, reverse, ans, path)
@@ -70,14 +70,14 @@ class Solution {
         endWord: String,
         beginWord: String,
         graph: Map<String, MutableSet<String>>,
-        ans: MutableList<List<String?>>,
-        path: MutableSet<String?>
+        ans: MutableList<List<String>>,
+        path: MutableSet<String>
     ) {
         val next = graph[endWord] ?: return
         for (word in next) {
             path.add(word)
             if (beginWord == word) {
-                val shortestPath: List<String?> = ArrayList(path)
+                val shortestPath: List<String> = ArrayList(path)
                 // reverse words in shortest path
                 Collections.reverse(shortestPath)
                 // add the shortest path to ans.