单词搜索 II

leetcode212 题难度困难
leetcode212. 单词搜索 II

题目描述

给定一个 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 中的所有字符串互不相同

解题回溯算法

数据范围只有，且 words 中出现的单词长度不会超过，可以考虑使用「回溯算法」。

回溯算法框架:
1.路径：也就是已经做出的选择。
2.选择列表：也就是你当前可以做的选择。
3.结束条件：也就是到达决策树底层，无法再做选择的条件。

result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

起始先将所有 words 出现的单词放到 Set 结构中，然后以 board 中的每个点作为起点进行爆搜（由于题目规定在一个单词中每个格子只能被使用一次，因此还需要一个 vis 数组来记录访问过的位置）：
1.如果当前爆搜到的字符串长度超过 10，直接剪枝；
2.如果当前搜索到的字符串在 Set 中，则添加到答案（同时了防止下一次再搜索到该字符串，需要将该字符串从 Set 中移除）。

代码演示

class Solution {
      //记录目标词汇
    Set<String> set = new HashSet<>();
    //记录四个方向,上下 左右
    private int[][]dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
    //记录长度
    int n ,m;
    //标记已经选择得
    boolean[][]vis = new boolean[13][13];
    //记录答案
    List<String> ans = new ArrayList<>();
    //维护一个全局的,方便进行回溯
    char[][]_board;

    /**
     * 单词搜索II
     * @param board
     * @param words
     * @return
     */
    public List<String> findWords(char[][] board, String[] words) {
        m = board.length;
        n = board[0].length;
        _board = board;
        for (String s : words){
            set.add(s);
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < m;i++){
            for (int j = 0; j < n;j++){
                vis[i][j] = true;
                sb.append(board[i][j]);
                dfs(i,j,sb);
                vis[i][j] = false;
                sb.deleteCharAt(sb.length() - 1);
            }
        }
        return ans;
    }

    /**
     * 回溯算法
     * @param i
     * @param j
     * @param sb
     */
    void dfs(int i,int j,StringBuilder sb){
        if (sb.length() > 10){
            return;
        }
        //收集答案
        if (set.contains(sb.toString())){
            ans.add(sb.toString());
            //已收集的答案删除掉
            set.remove(sb.toString());
        }
        //四个方向进行递归
        for (int[]d : dirs){
            int di = i + d[0];
            int dj = j + d[1];
            if (di < 0 || dj < 0 || di >= m || dj >= n){
                continue;
            }
            if (vis[di][dj]){
                continue;
            }
            vis[di][dj] = true;
            sb.append(_board[di][dj]);
            dfs(di,dj,sb);
            vis[di][dj] = false;
            sb.deleteCharAt(sb.length() - 1);
        }
    }

}