美文网首页
力扣79——单词搜索

力扣79——单词搜索

作者: 健健_1e44 | 来源:发表于2019-12-27 09:36 被阅读0次

    原题

    给定一个二维网格和一个单词,找出该单词是否存在于网格中。

    单词必须按照字母顺序,通过相邻的单元格内的字母构成,其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

    示例:

    board =
    [
      ['A','B','C','E'],
      ['S','F','C','S'],
      ['A','D','E','E']
    ]
    
    给定 word = "ABCCED", 返回 true.
    给定 word = "SEE", 返回 true.
    给定 word = "ABCB", 返回 false.
    

    原题url:https://leetcode-cn.com/problems/word-search/

    解题

    回溯

    拿到这题,我一开始想到的方法就是:

    • 以每一格为起点,开始寻找,寻找的条件是要保证当前的字母和下一个和它连接的字母(上下左右)都符合条件,那么就继续查找。
    • 只要当前不符合,立刻返回 false,快速失败。
    • 利用一个二维 boolean 数组记录每一格的使用情况,记住,如果从当前格出发都不成功的话,则需要回退

    接下来看看代码:

    class Solution {
        // 总行数
        int row;
        // 总列数
        int col;
        // 原数组
        char[][] board;
        // 需要寻找的字符数组
        char[] wordArray;
    
        public boolean exist(char[][] board, String word) {
            this.board = board;
            this.row = board.length;
            this.col = board[0].length;
            this.wordArray = word.toCharArray();
                    // 标记每一格是否用过的二维数组
            boolean[][] used = new boolean[row][col];
                    
                    // 以每一格为起点开始搜索
            for (int i = 0; i < row; i++) {
                for (int j = 0; j < col; j++) {
                    if (dfs(i, j, 0, used)) {
                        return true;
                    }
                }
            }
            return false;
        }
    
        public boolean dfs(int x, int y, int index, boolean[][] used) {
            // 当前位置是否符合条件
            if (board[x][y] != wordArray[index]) {
                return false;
            }
            // 全部找完了
            if (index == wordArray.length - 1) {
                return true;
            }
            // 设置当前格使用过了
            used[x][y] = true;
    
            // 寻找上下左右是否有符合下一个的情况
            
            // 上一格是否存在并且没有被使用过
            if (x > 0 && !used[x - 1][y]) {
                if (dfs(x - 1, y, index + 1, used)) {
                    return true;
                }
            }
    
            // 下一格是否存在并且没有被使用过
            if (x < row - 1 && !used[x + 1][y]) {
                if (dfs(x + 1, y, index + 1, used)) {
                    return true;
                }
            }
    
            // 左一格是否存在并且没有被使用过
            if (y > 0 && !used[x][y - 1]) {
                if (dfs(x, y - 1, index + 1, used)) {
                    return true;
                }
            }
    
            // 右一格是否存在并且没有被使用过
            if (y < col - 1 && !used[x][y + 1]) {
                if (dfs(x, y + 1, index + 1, used)) {
                    return true;
                }
            }
    
            // 上下左右的情况都走完了,因此回退,设置当前格没有使用过
            used[x][y] = false;
    
            return false;
        }
    }
    

    提交OK,执行用时:19 ms,内存消耗:38.3 MB。从时间上看起来还有不少优化的空间,那该怎么做呢?

    似乎无用的优化

    我看了别人更优的解法,发现思想都是一致的,只是在判断上可能会更加简洁一些,如果是判断快速失败的话,似乎没有什么本质上的区别。我将自己的写法稍微优化了一下:

    class Solution {
        // 总行数
        int row;
        // 总列数
        int col;
        // 原数组
        char[][] board;
        // 需要寻找的字符数组
        char[] wordArray;
    
        public boolean exist(char[][] board, String word) {
            this.board = board;
            this.row = board.length;
            this.col = board[0].length;
            this.wordArray = word.toCharArray();
            // 标记每一格是否用过的二维数组
            boolean[][] used = new boolean[row][col];
                    
            // 以每一格为起点开始搜索
            for (int i = 0; i < row; i++) {
                for (int j = 0; j < col; j++) {
                    if (dfs(i, j, 0, used)) {
                        return true;
                    }
                }
            }
            return false;
        }
    
        public boolean dfs(int x, int y, int index, boolean[][] used) {
            // 当前位置不存在或者使用过,则返回失败
            if (x < 0 || x >= row || y < 0 || y >= col || used[x][y]) {
                return false;
            }
    
            // 当前位置是否符合条件
            if (board[x][y] != wordArray[index]) {
                return false;
            }
            // 全部找完了
            if (index == wordArray.length - 1) {
                return true;
            }
            // 设置当前格使用过了
            used[x][y] = true;
    
            // 寻找上下左右是否有符合下一个的情况
            boolean flag = dfs(x - 1, y, index + 1, used) || dfs(x + 1, y, index + 1, used) ||
                            dfs(x, y - 1, index + 1, used) || dfs(x, y + 1, index + 1, used);
    
            // 上下左右的情况都走完了,因此回退,设置当前格没有使用过
            used[x][y] = false;
    
            return flag;
        }
    }
    

    提交OK,执行用时:5 ms,内存消耗:38.4 MB。用时上少了很多,应该在于判断上:

    • 针对位置是否存在的判断,之前的写法是判断下一个位置是否存在,分散在四个 if 判断中,现在是写在一个里面,用于判断当前位置。
    • 寻找上下左右时,因为逻辑运算||是支持短路的,所以和之前分在四个 if 中效果是差不多的,但看起来更加简洁。

    好吧,其实我自己也没有看懂为什么这样写时间上会减少,大家如果知道的话,欢迎在下方留言。

    总结

    以上就是这道题目我的解答过程了,不知道大家是否理解了。这道题主要就是回溯,针对边界情况需要注意,应该就没有其他问题了。

    有兴趣的话可以访问我的博客或者关注我的公众号、头条号,说不定会有意外的惊喜。

    https://death00.github.io/

    公众号:健程之道

    相关文章

      网友评论

          本文标题:力扣79——单词搜索

          本文链接:https://www.haomeiwen.com/subject/hjvroctx.html