LeetCode热题100（七）

79. 单词搜索

题目详情

https://leetcode.cn/problems/word-search/

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

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

示例 1：

复制代码

输入：board = [['A','B','C','E'],['S','F','C','S'],['A','D','E','E']], word = "ABCCED"
输出：true

示例 2：

复制代码

输入：board = [['A','B','C','E'],['S','F','C','S'],['A','D','E','E']], word = "SEE"
输出：true

示例 3：

复制代码

输入：board = [['A','B','C','E'],['S','F','C','S'],['A','D','E','E']], word = "ABCB"
输出：false

解答过程

自己没写出来核心思路是

从每一个格子出发，上下左右四个方向搜索
按顺序匹配单词的每一个字符
走过的格子不能回头走（标记为'#'）
走完一条路要恢复状态（回溯）

java 复制代码

int height;
int width;
static int[][] directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

public boolean exist(char[][] board, String word) {
    height = board.length;
    width = board[0].length;
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            if (dfs(board, word, i, j, 0)) {
                return true;
            }
        }
    }
    return false;
}

public boolean dfs(char[][] board, String word, int i, int j, int k) {
    if (board[i][j] != word.charAt(k)) {
        return false;
    }

    if (k == word.length() - 1) {
        return true;
    }

    char c = board[i][j];
    board[i][j] = '#';

    for (int[] direction : directions) {
        int x = i + direction[0];
        int y = j + direction[1];

        if (x >= 0 && x < height && y >= 0 && y < width && board[x][y]!='#') {
            if (dfs(board, word, x, y, k + 1)) {
                return true;
            }
        }
    }

    board[i][j] = c;

    return false;
}

131. 分割回文串

题目详情

https://leetcode.cn/problems/palindrome-partitioning/

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

示例 1：

复制代码

输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]

示例 2：

复制代码

输入：s = "a"
输出：[["a"]]

解答过程

核心思路是预处理回文子串 + 深度优先搜索（回溯）

一个子串 s[i...j] 是回文，必须同时满足 2 个条件

首尾字符相等：s[i] == s[j]
中间的子串也是回文：s[i+1 ... j-1] 是回文

然后使用dfs不断地切割、回溯字符串即可

java 复制代码

boolean[][] flag;
ArrayList<List<String>> lists = new ArrayList<>();
ArrayList<String> path = new ArrayList<>();

public List<List<String>> partition(String s) {
    int n = s.length();
    flag = new boolean[n][n];
    for (int i = 0; i < n; i++) {
        Arrays.fill(flag[i], true);
    }
    for (int l = n - 1; l >= 0; l--) {
        for (int r = l + 1; r < n; r++) {
            flag[l][r] = (s.charAt(l) == s.charAt(r)) && flag[l + 1][r - 1];
        }
    }

    for (boolean[] booleans : flag) {
        System.out.println(Arrays.toString(booleans));
    }

    dfs(s, 0);
    return lists;
}

// 回溯函数：i表示当前分割到字符串的第几个字符
public void dfs(String s, int i) {
    if (i == s.length()) {
        lists.add(new ArrayList<>(path));
        return;
    }
    for (int j = i; j < s.length(); j++) {
        if (flag[i][j]) {
            path.add(s.substring(i, j + 1));
            dfs(s, j + 1);
            path.remove(path.size() - 1);
        }
    }
}