Added tasks 64-208

Author: javadev

README.md

@@ -0,0 +1,60 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Scala/LeetCode-in-Scala?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala)
+[![](https://img.shields.io/github/forks/LeetCode-in-Scala/LeetCode-in-Scala?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala/fork)
+
+## 64\. Minimum Path Sum
+
+Medium
+
+Given a `m x n` `grid` filled with non-negative numbers, find a path from top left to bottom right, which minimizes the sum of all numbers along its path.
+
+**Note:** You can only move either down or right at any point in time.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/05/minpath.jpg)
+
+**Input:** grid = \[\[1,3,1],[1,5,1],[4,2,1]]
+
+**Output:** 7
+
+**Explanation:** Because the path 1 → 3 → 1 → 1 → 1 minimizes the sum. 
+
+**Example 2:**
+
+**Input:** grid = \[\[1,2,3],[4,5,6]]
+
+**Output:** 12 
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 200`
+*   `0 <= grid[i][j] <= 100`
+
+## Solution
+
+```scala
+object Solution {
+    def minPathSum(grid: Array[Array[Int]]): Int = {
+        val numRows = grid.length
+        val numCols = grid(0).length
+        val dp = Array.ofDim[Int](numRows, numCols)
+
+        for (r <- numRows - 1 to 0 by -1) {
+            for (c <- numCols - 1 to 0 by -1) {
+                if (r == numRows - 1 && c == numCols - 1) {
+                    dp(r)(c) = grid(r)(c)
+                } else if (r == numRows - 1) {
+                    dp(r)(c) = grid(r)(c) + dp(r)(c + 1)
+                } else if (c == numCols - 1) {
+                    dp(r)(c) = grid(r)(c) + dp(r + 1)(c)
+                } else {
+                    dp(r)(c) = grid(r)(c) + Math.min(dp(r + 1)(c), dp(r)(c + 1))
+                }
+            }
+        }
+        dp(0)(0)
+    }
+}
+```

src/main/scala/g0001_0100/s0064_minimum_path_sum/readme.md

@@ -0,0 +1,54 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Scala/LeetCode-in-Scala?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala)
+[![](https://img.shields.io/github/forks/LeetCode-in-Scala/LeetCode-in-Scala?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala/fork)
+
+## 70\. Climbing Stairs
+
+Easy
+
+You are climbing a staircase. It takes `n` steps to reach the top.
+
+Each time you can either climb `1` or `2` steps. In how many distinct ways can you climb to the top?
+
+**Example 1:**
+
+**Input:** n = 2
+
+**Output:** 2
+
+**Explanation:** There are two ways to climb to the top. 1. 1 step + 1 step 2. 2 steps 
+
+**Example 2:**
+
+**Input:** n = 3
+
+**Output:** 3
+
+**Explanation:** There are three ways to climb to the top. 1. 1 step + 1 step + 1 step 2. 1 step + 2 steps 3. 2 steps + 1 step 
+
+**Constraints:**
+
+*   `1 <= n <= 45`
+
+## Solution
+
+```scala
+object Solution {
+    def climbStairs(n: Int): Int = {
+        if (n < 2) {
+            return n
+        }
+        val cache = new Array[Int](n)
+
+        // Initialize the cache for the first two steps
+        cache(0) = 1
+        cache(1) = 2
+
+        // Fill in the cache using a loop
+        for (i <- 2 until n) {
+            cache(i) = cache(i - 1) + cache(i - 2)
+        }
+
+        cache(n - 1)
+    }
+}
+```

src/main/scala/g0001_0100/s0070_climbing_stairs/readme.md

@@ -0,0 +1,73 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Scala/LeetCode-in-Scala?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala)
+[![](https://img.shields.io/github/forks/LeetCode-in-Scala/LeetCode-in-Scala?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala/fork)
+
+## 72\. Edit Distance
+
+Hard
+
+Given two strings `word1` and `word2`, return _the minimum number of operations required to convert `word1` to `word2`_.
+
+You have the following three operations permitted on a word:
+
+*   Insert a character
+*   Delete a character
+*   Replace a character
+
+**Example 1:**
+
+**Input:** word1 = "horse", word2 = "ros"
+
+**Output:** 3
+
+**Explanation:** horse -> rorse (replace 'h' with 'r') rorse -> rose (remove 'r') rose -> ros (remove 'e') 
+
+**Example 2:**
+
+**Input:** word1 = "intention", word2 = "execution"
+
+**Output:** 5
+
+**Explanation:** intention -> inention (remove 't') inention -> enention (replace 'i' with 'e') enention -> exention (replace 'n' with 'x') exention -> exection (replace 'n' with 'c') exection -> execution (insert 'u') 
+
+**Constraints:**
+
+*   `0 <= word1.length, word2.length <= 500`
+*   `word1` and `word2` consist of lowercase English letters.
+
+## Solution
+
+```scala
+object Solution {
+    def minDistance(w1: String, w2: String): Int = {
+        val n1 = w1.length
+        val n2 = w2.length
+
+        if (n2 > n1) {
+            return minDistance(w2, w1)
+        }
+
+        var dp = Array.range(0, n2 + 1)
+
+        for (j <- 0 to n2) {
+            dp(j) = j
+        }
+
+        for (i <- 1 to n1) {
+            var pre = dp(0)
+            dp(0) = i
+
+            for (j <- 1 to n2) {
+                val tmp = dp(j)
+                dp(j) =
+                    if (w1(i - 1) != w2(j - 1))
+                        1 + Math.min(pre, Math.min(dp(j), dp(j - 1)))
+                    else
+                        pre
+                pre = tmp
+            }
+        }
+
+        dp(n2)
+    }
+}
+```

src/main/scala/g0001_0100/s0072_edit_distance/readme.md

@@ -0,0 +1,100 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Scala/LeetCode-in-Scala?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala)
+[![](https://img.shields.io/github/forks/LeetCode-in-Scala/LeetCode-in-Scala?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala/fork)
+
+## 73\. Set Matrix Zeroes
+
+Medium
+
+Given an `m x n` integer matrix `matrix`, if an element is `0`, set its entire row and column to `0`'s, and return _the matrix_.
+
+You must do it [in place](https://en.wikipedia.org/wiki/In-place_algorithm).
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/08/17/mat1.jpg)
+
+**Input:** matrix = \[\[1,1,1],[1,0,1],[1,1,1]]
+
+**Output:** [[1,0,1],[0,0,0],[1,0,1]] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/08/17/mat2.jpg)
+
+**Input:** matrix = \[\[0,1,2,0],[3,4,5,2],[1,3,1,5]]
+
+**Output:** [[0,0,0,0],[0,4,5,0],[0,3,1,0]] 
+
+**Constraints:**
+
+*   `m == matrix.length`
+*   `n == matrix[0].length`
+*   `1 <= m, n <= 200`
+*   <code>-2<sup>31</sup> <= matrix[i][j] <= 2<sup>31</sup> - 1</code>
+
+**Follow up:**
+
+*   A straightforward solution using `O(mn)` space is probably a bad idea.
+*   A simple improvement uses `O(m + n)` space, but still not the best solution.
+*   Could you devise a constant space solution?
+
+## Solution
+
+```scala
+object Solution {
+    @SuppressWarnings(Array("scala:S3776"))
+    def setZeroes(matrix: Array[Array[Int]]): Unit = {
+        val m = matrix.length
+        val n = matrix(0).length
+        var row0 = false
+        var col0 = false
+
+        // Check if the 0th column needs to be marked as all 0s in the future
+        for (row <- matrix) {
+            if (row(0) == 0) {
+                col0 = true
+            }
+        }
+
+        // Check if the 0th row needs to be marked as all 0s in the future
+        for (i <- 0 until n) {
+            if (matrix(0)(i) == 0) {
+                row0 = true
+            }
+        }
+
+        // Store the signals in the 0th row and column
+        for (i <- 1 until m) {
+            for (j <- 1 until n) {
+                if (matrix(i)(j) == 0) {
+                    matrix(i)(0) = 0
+                    matrix(0)(j) = 0
+                }
+            }
+        }
+
+        // Mark 0 for all cells based on signals from the 0th row and 0th column
+        for (i <- 1 until m) {
+            for (j <- 1 until n) {
+                if (matrix(i)(0) == 0 || matrix(0)(j) == 0) {
+                    matrix(i)(j) = 0
+                }
+            }
+        }
+
+        // Set the 0th column
+        for (i <- 0 until m) {
+            if (col0) {
+                matrix(i)(0) = 0
+            }
+        }
+
+        // Set the 0th row
+        for (i <- 0 until n) {
+            if (row0) {
+                matrix(0)(i) = 0
+            }
+        }
+    }
+}
+```

src/main/scala/g0001_0100/s0073_set_matrix_zeroes/readme.md

@@ -0,0 +1,52 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Scala/LeetCode-in-Scala?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala)
+[![](https://img.shields.io/github/forks/LeetCode-in-Scala/LeetCode-in-Scala?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala/fork)
+
+## 74\. Search a 2D Matrix
+
+Medium
+
+Write an efficient algorithm that searches for a value in an `m x n` matrix. This matrix has the following properties:
+
+*   Integers in each row are sorted from left to right.
+*   The first integer of each row is greater than the last integer of the previous row.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/05/mat.jpg)
+
+**Input:** matrix = \[\[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
+
+**Output:** true 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/10/05/mat2.jpg)
+
+**Input:** matrix = \[\[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
+
+**Output:** false 
+
+**Constraints:**
+
+*   `m == matrix.length`
+*   `n == matrix[i].length`
+*   `1 <= m, n <= 100`
+*   <code>-10<sup>4</sup> <= matrix[i][j], target <= 10<sup>4</sup></code>
+
+## Solution
+
+```scala
+object Solution {
+    def searchMatrix(matrix: Array[Array[Int]], target: Int): Boolean = {
+        var i = matrix.length - 1
+        val n = matrix.last.length - 1
+        var j = 0
+        while (i >= 0 && j <= n) {
+            if (matrix(i)(j) == target) return true
+            else if (matrix(i)(j) > target) i -= 1
+            else j += 1
+        }
+        false
+    }
+}
+```