My code:
import java.util.HashSet;
public class Solution {
private int width = 0;
private int height = 0;
public boolean exist(char[][] board, String word) {
if (board == null)
return false;
if (board.length == 0)
return false;
if (word == null || word.length() == 0)
return false;
width = board[0].length;
height = board.length;
HashSet isVisited = new HashSet();
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
boolean ret = helper(i, j, 0, board, word, isVisited);
if (ret)
return true;
}
}
return false;
}
private boolean helper(int i, int j, int begin, char[][] board, String word, HashSet isVisited) {
if (!isValid(i, j, isVisited))
return false;
if (board[i][j] != word.charAt(begin))
return false;
if (begin == word.length() - 1)
return true;
isVisited.add(i * width + j);
if (helper(i - 1, j, begin + 1, board, word, isVisited))
return true;
if (helper(i + 1, j, begin + 1, board, word, isVisited))
return true;
if (helper(i, j - 1, begin + 1, board, word, isVisited))
return true;
if (helper(i, j + 1, begin + 1, board, word, isVisited))
return true;
isVisited.remove(i * width + j);
return false;
}
/**
* detect whether this location in array is valid. If it is visited, it is invalid
* @param i row
* @param j col
* @param isVisited boolean[][]
* @return whether it is valid
*/
private boolean isValid(int i, int j, HashSet isVisited) {
if (i < 0 || i >= height)
return false;
if (j < 0 || j >= width)
return false;
return !isVisited.contains(i * width + j);
}
public static void main(String[] args) {
char[][] board = new char[3][4];
board[0][0] = 'A';
board[0][1] = 'B';
board[0][2] = 'C';
board[0][3] = 'E';
board[1][0] = 'S';
board[1][1] = 'F';
board[1][2] = 'C';
board[1][3] = 'S';
board[2][0] = 'A';
board[2][1] = 'D';
board[2][2] = 'E';
board[2][3] = 'E';
Solution test = new Solution();
System.out.println(test.exist(board, "ADFA"));
}
}
总算是过了测试。一开始我是用一个，
boolean[][] isVisited 数组来做的。然后每次递归，为了避免重复访问同一个元素，我都需要把原布尔数组拷贝一份传入下层递归。四个方向，上下左右，都需要拷贝一下原数组。当原数组无比巨大时，而我的每一次递归又都需要拷贝四次原数组，导致我的时间测试过不了。我在八皇后问题中就是用这个办法做的，现在看来不是很好，或者说，很糟糕。因为数组只是很少的一部分发生了改变，但我需要重新拷贝整个数组。很像是 meng project 中的bitmap, 浪费了大量的内存。
然后我换用了一个HashSet
之后再删除。避免了布尔数组的问题并且可以达到相同的效果。
于是，过了测试。但是时间仍然很高。
然后我看了答案。
发现，我的HashSet在递归前插入元素，递归后删除元素的做法可以再简化。
递归前，设置该元素为board[i][j] = '#', 因为 #不是字母，所以以后的深层递归是无法访问到他的。
递归后，再把他改回来，不要影响其他循环下的递归。
代码如下：
public class Solution {
private int width = 0;
private int height = 0;
public boolean exist(char[][] board, String word) {
if (board == null)
return false;
if (board.length == 0)
return false;
if (word == null || word.length() == 0)
return false;
width = board[0].length;
height = board.length;
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
boolean ret = helper(i, j, 0, board, word);
if (ret)
return true;
}
}
return false;
}
private boolean helper(int i, int j, int begin, char[][] board, String word) {
if (i < 0 || i >= height || j < 0 || j >= width)
return false;
if (board[i][j] != word.charAt(begin))
return false;
char temp = board[i][j];
board[i][j] = '#';
if (begin == word.length() - 1)
return true;
if (helper(i - 1, j, begin + 1, board, word))
return true;
if (helper(i + 1, j, begin + 1, board, word))
return true;
if (helper(i, j - 1, begin + 1, board, word))
return true;
if (helper(i, j + 1, begin + 1, board, word))
return true;
board[i][j] = temp;
return false;
}
public static void main(String[] args) {
char[][] board = new char[3][4];
board[0][0] = 'A';
board[0][1] = 'B';
board[0][2] = 'C';
board[0][3] = 'E';
board[1][0] = 'S';
board[1][1] = 'F';
board[1][2] = 'C';
board[1][3] = 'S';
board[2][0] = 'A';
board[2][1] = 'D';
board[2][2] = 'E';
board[2][3] = 'E';
Solution test = new Solution();
System.out.println(test.exist(board, "ADFA"));
}
}
http://www.programcreek.com/2014/06/leetcode-word-search-java/
思想其实一直没变过。就是dfs, 不停地往深层递归。就是八皇后问题。
这类问题的统一思想就是，
知道最终的目的是什么，确定停止条件。即什么时候返回true，不再往下递归。
然后，每次递归的时候，往上下左右各个方向扩散，并且判断这些扩散的方向是否有效。他们是否越界了？
他们是否之前已经被访问过了。
如果判断之前是否被访问过了，最简单的做法就是布尔数组，然后再每次深层递归时重新拷贝一份传进去。
但完全可以用HashSet
然后这道题目告诉我们还可以再简化。
将该元素设置为一个不满足再次深层递归条件的元素。这样，深层递归时再次访问到该元素时会自动停止。这样就避免了HashSet操作所带来的消耗。递归结束后，再将该元素恢复到原来的值，避免影响其他循环中的递归。
for (int i = 0; i < height; i++)
for (int j = 0; j < width; j++)
helper(...); // recursive function
**
Anyway, Good luck, Richardo!
**
My code:
public class Solution {
int row = 0;
int col = 0;
public boolean exist(char[][] board, String word) {
if (board == null || board.length == 0 || board[0].length == 0 || word == null || word.length() == 0) {
return false;
}
row = board.length;
col = board[0].length;
boolean[][] isVisited = new boolean[row][col];
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
isVisited[i][j] = true;
boolean flag = helper(0, word, i, j, board, isVisited);
isVisited[i][j] = false;
if (flag) {
return true;
}
}
}
return false;
}
private boolean helper(int position, String word, int i, int j, char[][] board, boolean[][] isVisited) {
if (position == word.length() - 1) {
char curr = word.charAt(position);
if (curr == board[i][j]) {
return true;
}
else {
return false;
}
}
else {
char curr = word.charAt(position);
if (curr == board[i][j]) {
if (isValid(i + 1, j) && !isVisited[i + 1][j]) {
isVisited[i + 1][j] = true;
boolean flag = helper(position + 1, word, i + 1, j, board, isVisited);
isVisited[i + 1][j] = false;
if (flag)
return flag;
}
if (isValid(i - 1, j) && !isVisited[i - 1][j]) {
isVisited[i - 1][j] = true;
boolean flag = helper(position + 1, word, i - 1, j, board, isVisited);
isVisited[i - 1][j] = false;
if (flag)
return flag;
}
if (isValid(i, j + 1) && !isVisited[i][j + 1]) {
isVisited[i][j + 1] = true;
boolean flag = helper(position + 1, word, i, j + 1, board, isVisited);
isVisited[i][j + 1] = false;
if (flag)
return flag;
}
if (isValid(i, j - 1) && !isVisited[i][j - 1]) {
isVisited[i][j - 1] = true;
boolean flag = helper(position + 1, word, i, j - 1, board, isVisited);
isVisited[i][j - 1] = false;
if (flag)
return flag;
}
return false;
}
else {
return false;
}
}
}
private boolean isValid(int i, int j) {
if (i >= 0 && i < row && j >= 0 && j < col) {
return true;
}
else {
return false;
}
}
}
这道题目就是dfs,体力活。没什么难度。
Anyway, Good luck, Richardo! -- 09/02/2016