LeetCode 212 单词搜索II Java

最新推荐文章于 2021-09-19 10:56:13 发布

qq_40742615

最新推荐文章于 2021-09-19 10:56:13 发布

阅读量141

点赞数

分类专栏： leetcode 文章标签： leetcode java

本文链接：https://blog.csdn.net/qq_40742615/article/details/120328822

版权

leetcode 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

这是一个关于如何在给定的二维字符网格中通过回溯搜索算法查找并返回与字典中匹配的单词的博客。示例展示了在不同输入情况下，如何找出所有同时存在于网格和字典中的单词。博客内容包括了算法思路、样例代码以及对于复杂问题的优化考虑。

摘要由CSDN通过智能技术生成

题目：

给定一个 m x n 二维字符网格 board 和一个单词（字符串）列表 words，找出所有同时在二维网格和字典中出现的单词。

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

示例 1：

输入：board = [["o","a","a","n"],["e","t","a","e"],["i","h","k","r"],["i","f","l","v"]], words = ["oath","pea","eat","rain"]
输出：["eat","oath"]

示例 2：

输入：board = [["a","b"],["c","d"]], words = ["abcb"]
输出：[]

提示
- m == board.length
- n == board[i].length
- 1 <= m, n <= 12
- board[i][j] 是一个小写英文字母
- 1 <= words.length <= 3 * 104
- 1 <= words[i].length <= 10
- words[i] 由小写英文字母组成
- words 中的所有字符串互不相同

思路：

使用回溯遍历所有单词

样例代码

public List<String> findWords(char[][] board, String[] words) {
    Map<Character, List<Integer[]>> map = new HashMap<>(words.length);

    // 找出每个字母的位置
    for (int i = 0; i < board.length; i++) {
        for (int j = 0; j < board[i].length; j++) {
            if (map.containsKey(board[i][j])) {
                map.get(board[i][j]).add(new Integer[]{i, j});
            } else {
                List<Integer[]> list = new ArrayList<>();
                list.add(new Integer[]{i, j});
                map.put(board[i][j], list);
            }
        }
    }


    Set<String> result = new HashSet<>();
    for (String word : words) {
        isContains=false;
        for (Integer[] arr : map.getOrDefault(word.charAt(0), Collections.emptyList())) {
            if(result.contains(word)){
                break;
            }
            // 用来标记这个位置是否已经走过了
            int[][] flagArr = new int[board.length][board[0].length];
            flagArr[arr[0]][arr[1]] = 1;
            dfs(result, word, board, flagArr, arr[0], arr[1], 0);
        }

    }
    return new ArrayList<>(result);

}
boolean isContains=false;
private void dfs(Set<String> result, String word, char[][] board, int[][] flagArr, int x, int y, int index) {

    if (isContains) {
        return;
    }

    if (index == word.length() - 1) {
        isContains=true;
        result.add(word);
        return;
    }

    // 上走
    if (x > 0 && flagArr[x - 1][y] != 1 && board[x - 1][y] == word.charAt(index + 1)) {
        flagArr[x - 1][y] = 1;
        dfs(result, word, board, flagArr, x - 1, y, index + 1);
        flagArr[x - 1][y] = 0;
    }

    // 下走
    if (x < flagArr.length - 1 && flagArr[x + 1][y] != 1 && board[x + 1][y] == word.charAt(index + 1)) {
        flagArr[x + 1][y] = 1;
        dfs(result, word, board, flagArr, x + 1, y, index + 1);
        flagArr[x + 1][y] = 0;
    }

    // 左走
    if (y > 0 && flagArr[x][y - 1] != 1 && board[x][y - 1] == word.charAt(index + 1)) {
        flagArr[x][y - 1] = 1;
        dfs(result, word, board, flagArr, x, y - 1, index + 1);
        flagArr[x][y - 1] = 0;
    }


    // 右走
    if (y < flagArr[x].length - 1 && flagArr[x][y + 1] != 1 && board[x][y + 1] == word.charAt(index + 1)) {
        flagArr[x][y + 1] = 1;
        dfs(result, word, board, flagArr, x, y + 1, index + 1);
        flagArr[x][y + 1] = 0;
    }


}