Update some DP solutions

Author: enginebai

leetcode/279.perfect-squares.md

@@ -20,20 +20,43 @@ dp[13] = min(
 
 So `dp[n] = min(dp[n - i*i] + 1)` where `n - i*i >= 0` and `i` starts from 1.
 
+### Top-Down DP
+```kotlin
+private val memo = hashMapOf<Int, Int>()
+
+fun numSquares(n: Int): Int {
+    if (n == 0) return 0
+    if (n == 1) return 1
+    if (memo.containsKey(n)) return memo[n]!!
+    var results = Int.MAX_VALUE
+    for (i in 1..n) {
+        val square = i * i
+        if (square <= n) {
+            results = min(results, numSquares(n - square) + 1)
+        } else {
+            break
+        }
+    }
+    memo[n] = results
+    return results
+}
+```
+
 ```kotlin
 fun numSquares(n: Int): Int {
-    if (n <= 1) return n
-    val dp = IntArray(n + 1)
+    val dp = IntArray(n + 1) { _ -> Int.MAX_VALUE }
     dp[0] = 0
     dp[1] = 1
-    
     for (i in 2..n) {
-        val sqrt = sqrt(i.toDouble()).toInt()
-        var min = Int.MAX_VALUE
-        for (j in 1..sqrt) {
-            min = min(dp[i - j * j] + 1, min)
+        // Loop through every perfect square
+        for (j in 1..i) {
+            val square = j * j
+            if (square <= i) {
+                dp[i] = min(dp[i], dp[i - square] + 1)
+            } else {
+                break
+            }
         }
-        dp[i] = min
     }
     return dp[n]
 }

leetcode/49.group-anagrams.md

@@ -29,21 +29,11 @@ private fun countLetters(str: String): IntArray {
 }
 
 private fun hashCountLetters(countArray: IntArray): String {
-    val hash = StringBuilder()
-    for (i in 0 until 26) {
-        // Output: a2d6e1
-        if (countArray[i] > 0) {
-            hash.append("${'a' + i}")
-            hash.append("${countArray[i].toString()}")    
-        }
-
-        // My attempt (AC) but worse time and space complexity
-        // Comma is required, to separate the alphabet.
-        // Output: 2006100000000...
-        // val x = 'a' + i
-        // hash.append("${countArray[i].toString()},")
+    val s = StringBuilder()
+    for (i in 0 until count.size) {
+        s.append("${count[i]},")
     }
-    return hash.toString()
+    return s.toString()
 }
 ```