每日一题——单词搜索

菜鸡每日一题系列打卡79天

每天一道算法题目 

小伙伴们一起留言打卡

坚持就是胜利，我们一起努力！

题目描述(引自LeetCode)

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

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

示例:
board =
[
  ['A','B','C','E'],
  ['S','F','C','S'],
  ['A','D','E','E']
]


给定 word = "ABCCED", 返回 true
给定 word = "SEE", 返回 true
给定 word = "ABCB", 返回 false

提示：

• board 和 word 中只包含大写和小写英文字母。

• 1 <= board.length <= 200

• 1 <= board[i].length <= 200

• 1 <= word.length <= 10^3

题目分析

这道单词搜索的题目，实质上是一道图的遍历的变形题目，对于题目寻找指定单词的要求，我们可以采用DFS进行实现。DFS的算法实际上采用的是我们的老朋友——回溯的思想。话不多说，上代码！

代码实现

public class Solution {


    private int[][] direction = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};
    private boolean[][] visited;
    private int row;
    private int column;


    public boolean exist(char[][] board, String word) {
        if (board == null || board.length == 0) return false;
        row = board.length;
        column = board[0].length;
        visited = new boolean[row][column];
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < column; j++) {
                if (dfs(i, j, 0, board, word)) return true;
            }
        }
        return false;
    }


    private boolean dfs(int x, int y, int current, char[][]board, String word) {
        if (current == word.length() - 1) return board[x][y] == word.charAt(current);
        if (board[x][y] == word.charAt(current)) {
            visited[x][y] = true;
            for (int[] array : direction) {
                int tmpX = x + array[0], tmpY = y + array[1];
                if (check(tmpX, tmpY) && !visited[tmpX][tmpY]) {
                    if (dfs(tmpX, tmpY, current + 1, board, word)) return true;
                }
            }
            visited[x][y] = false;
        }
        return false;
    }


    private boolean check(int x, int y) {
        return x >= 0 && x < row && y >= 0 && y < column;
    }
}

代码分析

对代码进行分析，程序采用了回溯法，其在最坏情况下的时间复杂度是指数级别的；而就空间而言，采用了m * n大小的状态数组来记录访问情况，因此，空间复杂度为O(mn)。

执行结果

学习 | 工作 | 分享

????长按关注“有理想的菜鸡”

只有你想不到，没有你学不到