4242``` python
4343class Solution :
4444 def exist (self board : List[List[str ]], word : str ) -> bool :
45- def dfs (i , j , cur ):
46- if cur == len (word):
45+ def dfs (i , j , k ):
46+ if k == len (word):
4747 return True
48- if i < 0 or i >= m or j < 0 or j >= n or visited[i][j] or word[cur ] != board[i][j]:
48+ if i < 0 or i >= m or j < 0 or j >= n or word[k ] != board[i][j]:
4949 return False
50- visited [i][j] = True
51- next = cur + 1
52- res = dfs(i + 1 , j, next ) or dfs(i - 1 , j, next ) or dfs(i, j + 1 , next ) or dfs(i, j - 1 , next )
53- visited[i][j] = False
54- return res
50+ board [i][j] = ' '
51+ ans = any (dfs(i + a, j + b, k + 1 ) for a, b in [[ 0 , - 1 ], [ 0 , 1 ], [ 1 , 0 ], [ - 1 , 0 ]])
52+ board[i][j] = word[k]
53+ return ans
54+ 5555 m, n = len (board), len (board[0 ])
56- visited = [[False for _ in range (n)] for _ in range (m)]
57- for i in range (m):
58- for j in range (n):
59- res = dfs(i, j, 0 )
60- if res:
61- return True
62- return False
56+ return any (dfs(i, j, 0 ) for i in range (m) for j in range (n))
6357```
6458
6559### ** Java**
6660
6761``` java
6862class Solution {
69- private boolean [][] visited;
63+ private char [][] board;
64+ private String word;
65+ private int m;
66+ private int n;
7067
7168 public boolean exist (char [][] board , String word ) {
72- int m = board. length, n = board[0 ]. length;
73- visited = new boolean [m][n];
74- char [] chars = word. toCharArray();
69+ m = board. length;
70+ n = board[0 ]. length;
71+ this . board = board;
72+ this . word = word;
7573 for (int i = 0 ; i < m; ++ i) {
7674 for (int j = 0 ; j < n; ++ j) {
77- boolean res = dfs(board, i, j, chars, 0 );
78- if (res) return true ;
75+ if (dfs(i, j, 0 )) {
76+ return true ;
77+ }
7978 }
8079 }
8180 return false ;
8281 }
8382
84- private boolean dfs (char [][] board , int i , int j , char [] chars , int cur ) {
85- if (cur == chars. length) return true ;
86- if (i < 0 || i >= board. length || j < 0 || j >= board[0 ]. length) return false ;
87- if (visited[i][j] || board[i][j] != chars[cur]) return false ;
88- visited[i][j] = true ;
89- int next = cur + 1 ;
90- boolean res = dfs(board, i + 1 , j, chars, next)
91- || dfs(board, i - 1 , j, chars, next)
92- || dfs(board, i, j + 1 , chars, next)
93- || dfs(board, i, j - 1 , chars, next);
94- visited[i][j] = false ;
95- return res;
83+ private boolean dfs (int i , int j , int k ) {
84+ if (k == word. length()) {
85+ return true ;
86+ }
87+ if (i < 0 || i >= m || j < 0 || j >= n || word. charAt(k) != board[i][j]) {
88+ return false ;
89+ }
90+ board[i][j] = ' '
91+ int [] dirs = {- 1 , 0 , 1 , 0 , - 1 };
92+ boolean ans = false ;
93+ for (int l = 0 ; l < 4 ; ++ l) {
94+ ans = ans || dfs(i + dirs[l], j + dirs[l + 1 ], k + 1 );
95+ }
96+ board[i][j] = word. charAt(k);
97+ return ans;
9698 }
9799}
98100```
@@ -106,136 +108,91 @@ class Solution {
106108 * @return {boolean}
107109 */
108110var exist = function (board , word ) {
109- let row = board .length ;
110- let col = board[0 ].length ;
111- let res = false ;
112- let isRead = [... new Array (row)].map (() => Array (col).fill (0 ));
113- for (let i = 0 ; i < row; i++ ) {
114- for (let j = 0 ; j < col; j++ ) {
115- if (res) break ;
116- if (board[i][j] === word[0 ]) {
117- dfs (i, j, word);
118- }
111+ const m = board .length ;
112+ const n = board[0 ].length ;
113+ let dfs = function (i , j , k ) {
114+ if (k == word .length ) {
115+ return true ;
119116 }
120- }
121- function dfs (i , j , word ) {
122- if (
123- i < 0 ||
124- j < 0 ||
125- i >= row ||
126- j >= col ||
127- res ||
128- isRead[i][j] ||
129- board[i][j] !== word[0 ]
130- ) {
131- return ;
117+ if (i < 0 || i >= m || j < 0 || j >= n || board[i][j] != word[k]) {
118+ return false ;
132119 }
133- isRead[i][j] = 1 ;
134- word = word .substring (1 );
135- if (word .length ) {
136- dfs (i - 1 , j, word);
137- dfs (i + 1 , j, word);
138- dfs (i, j - 1 , word);
139- dfs (i, j + 1 , word);
140- } else {
141- res = true ;
142- return ;
120+ board[i][j] = ' '
121+ let ans = false ;
122+ let dirs = [- 1 , 0 , 1 , 0 , - 1 ];
123+ for (let l = 0 ; l < 4 ; ++ l) {
124+ ans = ans || dfs (i + dirs[l], j + dirs[l + 1 ], k + 1 );
125+ }
126+ board[i][j] = word[k];
127+ return ans;
128+ };
129+ for (let i = 0 ; i < m; ++ i) {
130+ for (let j = 0 ; j < n; ++ j) {
131+ if (dfs (i, j, 0 )) {
132+ return true ;
133+ }
143134 }
144- isRead[i][j] = 0 ;
145135 }
146- return res ;
136+ return false ;
147137};
148138```
149139
150140### ** Go**
151141
152142``` go
153143func exist (board [][]byte , word string ) bool {
154- if len (board) == 0 {
155- return false
156- }
157- // 标记数组
158- isVisited := make ([][]bool , len (board))
159- for i := 0 ; i < len (board); i++ {
160- isVisited[i] = make ([]bool , len (board[0 ]))
144+ m , n := len (board), len (board[0 ])
145+ var dfs func (i, j, k int ) bool
146+ dfs = func (i, j, k int ) bool {
147+ if k == len (word) {
148+ return true
149+ }
150+ if i < 0 || i >= m || j < 0 || j >= n || board[i][j] != word[k] {
151+ return false
152+ }
153+ board[i][j] = ' '
154+ dirs := []int {-1 , 0 , 1 , 0 , -1 }
155+ ans := false
156+ for l := 0 ; l < 4 ; l++ {
157+ ans = ans || dfs (i+dirs[l], j+dirs[l+1 ], k+1 )
158+ }
159+ board[i][j] = word[k]
160+ return ans
161161 }
162- for i := 0 ; i < len (board); i++ {
163- for j := 0 ; j < len (board[0 ]); j++ {
164- if board[i][j] == word[0 ] {
165- if bfs (board, i, j, isVisited, word, 0 ) {
166- return true
167- }
162+ for i := 0 ; i < m; i++ {
163+ for j := 0 ; j < n; j++ {
164+ if dfs (i, j, 0 ) {
165+ return true
168166 }
169167 }
170168 }
171169 return false
172170}
173- 174- func bfs (board [][]byte , i , j int , isVisited [][]bool , word string , index int ) bool {
175- if index == len (word) {
176- return true
177- }
178- if i < 0 || j < 0 || i == len (board) || j == len (board[0 ]) || isVisited[i][j] || board[i][j] != word[index] {
179- return false
180- }
181- isVisited[i][j] = true
182- res := bfs (board, i+1 , j, isVisited, word, index+1 ) ||
183- bfs (board, i, j+1 , isVisited, word, index+1 ) ||
184- bfs (board, i-1 , j, isVisited, word, index+1 ) ||
185- bfs (board, i, j-1 , isVisited, word, index+1 )
186- isVisited[i][j] = false
187- return res
188- }
189171```
190172
191173### ** C++**
192174
193175``` cpp
194176class Solution {
195177public:
196- bool dfs(vector<vector<char >>& board, string& word, int cur, int x, int y) {
197- if (board[ x] [ y ] != word[ cur] ) {
198- return false;
199- }
200- 201- if (cur == word.size()-1) {
202- return true;
203- }
204- 205- char t = board[x][y];
206- board[x][y] = ' *' // 表示查询过了这个字段
207- int dx[4 ] = {-1, 0, 1, 0};
208- int dy[ 4] = {0, 1, 0, -1};
209- for (int k = 0; k < 4; k++) {
210- // 从上、右、下、左四个方向,开始dfs
211- int a = x + dx[ k] , b = y + dy[ k] ;
212- if (a >= 0 && a < board.size() && b >= 0 && b < board[ 0] .size()) {
213- if (dfs(board, word, cur+1, a, b)) {
214- return true;
215- }
216- }
217- }
218- 219- board[x][y] = t;
220- return false;
221- }
222- 223178 bool exist(vector<vector<char >>& board, string word) {
224- int x = board.size();
225- int y = board[0].size();
226- if (0 == x || 0 == y) {
227- return false;
228- }
229- 230- for (int i = 0; i < x; i++) {
231- for (int j = 0; j < y; j++) {
232- if (dfs(board, word, 0, i, j)) {
233- return true;
234- }
235- }
236- }
179+ for (int i = 0; i < board.size(); ++i)
180+ for (int j = 0; j < board[ 0] .size(); ++j)
181+ if (dfs(i, j, 0, board, word))
182+ return 1;
183+ return 0;
184+ }
237185
238- return false;
186+ bool dfs(int i, int j, int k, vector<vector<char>>& board, string word) {
187+ if (k == word.size()) return 1;
188+ if (i < 0 || i >= board.size() || j < 0 || j >= board[0].size() || board[i][j] != word[k]) return 0;
189+ vector<int> dirs = {-1, 0, 1, 0, -1};
190+ board[i][j] = ' ';
191+ bool ans = 0;
192+ for (int l = 0; l < 4; ++l)
193+ ans = ans || dfs(i + dirs[l], j + dirs[l + 1], k + 1, board, word);
194+ board[i][j] = word[k];
195+ return ans;
239196 }
240197};
241198```
0 commit comments