每日算法题：19.8.18

最新推荐文章于 2021-05-20 15:56:32 发布

原创最新推荐文章于 2021-05-20 15:56:32 发布 · 138 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法

算法专栏收录该内容

66 篇文章

订阅专栏

本文介绍了一种在二维网格中查找特定单词的算法实现。单词必须按照字母顺序，通过相邻单元格内的字母构成，且同一单元格字母不可重复使用。文章详细展示了如何递归地检查每个可能的路径，以确定单词是否存在。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：

给定一个二维网格和一个单词，找出该单词是否存在于网格中。
单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

示例：

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

输出：true

代码：

public class Test25 {
    @Test
    public void test(){
        char[][] board =new char[][]{{'a'}};
        System.out.println(new Test25().exist(board, "ab"));
    }

    public boolean exist(char[][] board, String word) {
        char[] targets = word.toCharArray();
        int index = 0;
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[i].length; j++) {
                if (board[i][j]==targets[index]) {
                    List<Integer> exists = new ArrayList<>();
                    exists.add(i*10+j);
                    if (function(i,j,index+1,targets,exists,board)) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    public boolean function(int rowIndex, int columnIndex, int index, char[] targets, List<Integer> exists,char[][] board){
        if (index==targets.length) {
            return true;
        }

        if (rowIndex>0) {
            if (board[rowIndex-1][columnIndex]==targets[index] && !exists.contains((rowIndex-1)*10+columnIndex)){
                List<Integer> temp = new ArrayList<>();
                temp.addAll(exists);
                temp.add((rowIndex-1)*10+columnIndex);
                if (function(rowIndex-1,columnIndex,index+1,targets,temp,board)) {
                    return true;
                }
            }
        }

        if (columnIndex>0) {
            if (board[rowIndex][columnIndex-1]==targets[index] && !exists.contains((rowIndex)*10+columnIndex-1)){
                List<Integer> temp = new ArrayList<>();
                temp.addAll(exists);
                temp.add((rowIndex)*10+columnIndex-1);
                if (function(rowIndex,columnIndex-1,index+1,targets,temp,board)) {
                    return true;
                }
            }
        }

        if (rowIndex<board.length-1) {
            if (board[rowIndex+1][columnIndex]==targets[index] && !exists.contains((rowIndex+1)*10+columnIndex)){
                List<Integer> temp = new ArrayList<>();
                temp.addAll(exists);
                temp.add((rowIndex+1)*10+columnIndex);
                if (function(rowIndex+1,columnIndex,index+1,targets,temp,board)) {
                    return true;
                }
            }
        }

        if (columnIndex<board[0].length-1) {
            if (board[rowIndex][columnIndex+1]==targets[index] && !exists.contains((rowIndex)*10+columnIndex+1)){
                List<Integer> temp = new ArrayList<>();
                temp.addAll(exists);
                temp.add((rowIndex)*10+columnIndex+1);
                if (function(rowIndex,columnIndex+1,index+1,targets,temp,board)) {
                    return true;
                }
            }
        }

        return false;
    }
}