使用kotlin解决这个问题：1091. 二进制矩阵中的最短路径 提示 中等 277 相关企业 给你一个 n x n 的二进制矩阵 grid 中，返回矩阵中最短 畅通路径 的长度。如果不存在这样的路径，返回 -1 。 二进制矩阵中的 畅通路径 是一条从 左上角 单元格（即，(0, 0)）到 右下角 单元格（即，(n - 1, n - 1)）的路径，该路径同时满足下述要求： 路径途经的所有单元格都的值都是 0 。 路径中所有相邻的单元格应当在 8 个方向之一 上连通（即，相邻两单元之间彼此不同且共享一条边或者一个角）。 畅通路径的长度 是该路径途经的单元格总数。 示例 1： 输入：grid = [[0,1],[1,0]] 输出：2 示例 2： 输入：grid = [[0,0,0],[1,1,0],[1,1,0]] 输出：4 示例 3： 输入：grid = [[1,0,0],[1,1,0],[1,1,0]] 输出：-1 提示： n == grid.length n == grid[i].length 1 <= n <= 100 grid[i][j] 为 0 或 1

以下是使用Kotlin解决1091题的代码：

import java.util.*

class Solution {
    fun shortestPathBinaryMatrix(grid: Array<IntArray>): Int {
        val n = grid.size
        if (grid[0][0] == 1 || grid[n - 1][n - 1] == 1) {
            return -1
        }
        val dx = intArrayOf(-1, -1, 0, 1, 1, 1, 0, -1)
        val dy = intArrayOf(0, 1, 1, 1, 0, -1, -1, -1)
        val queue: Queue<Pair<Int, Int>> = LinkedList()
        queue.offer(Pair(0, 0))
        var step = 1
        while (queue.isNotEmpty()) {
            val size = queue.size
            for (i in 0 until size) {
                val curr = queue.poll()
                if (curr.first == n - 1 && curr.second == n - 1) {
                    return step
                }
                for (j in 0 until 8) {
                    val x = curr.first + dx[j]
                    val y = curr.second + dy[j]
                    if (x in 0 until n && y in 0 until n && grid[x][y] == 0) {
                        grid[x][y] = 1
                        queue.offer(Pair(x, y))
                    }
                }
            }
            step++
        }
        return -1
    }
}

该算法使用BFS（广度优先搜索）来遍历矩阵，并使用一个队列来记录遍历过的格子。在遍历的过程中，如果当前格子是终点，则返回当前步数；如果不是，则将其所有相邻的格子加入队列中，并标记为已经访问过。最后如果没有找到终点则返回-1。

时间复杂度：O(n^2)，其中n为矩阵的大小，因为每个格子最多只会被加入队列一次。

空间复杂度：O(n^2)，因为需要使用一个n*n大小的数组来记录每个格子是否被访问过。