Google编程大赛解题一道

Google编程大赛的题目的确对算法、思维能力是一个考验，在一个小时内完成的确是有点难度。经过检验，才发现自己在这方面平时的确比较欠缺呀。这道题我可是做了近半天才作完整了，跑通了题目给出的所有case。
原题：
Problem Statement
You are given a String[] grid representing a rectangular grid of letters. You are also given a String find, a word you are to find within the grid. The starting point may be anywhere in the grid. The path may move up, down, left, right, or diagonally from one letter to the next, and may use letters in the grid more than once, but you may not stay on the same cell twice in a row (see example 6 for clarification).
You are to return an int indicating the number of ways find can be found within the grid. If the result is more than 1,000,000,000, return -1.
Definition
Class:
WordPath
Method:
countPaths
Parameters:
String[], String
Returns:
int
Method signature:
int countPaths(String[] grid, String find)
(be sure your method is public)

Constraints
-
grid will contain between 1 and 50 elements, inclusive.
-
Each element of grid will contain between 1 and 50 uppercase ('A'-'Z') letters, inclusive.
-
Each element of grid will contain the same number of characters.
-
find will contain between 1 and 50 uppercase ('A'-'Z') letters, inclusive.
Examples
0)

{"ABC",
 "FED",
 "GHI"}
"ABCDEFGHI"
Returns: 1
There is only one way to trace this path. Each letter is used exactly once.
1)

{"ABC",
 "FED",
 "GAI"}
"ABCDEA"
Returns: 2
Once we get to the 'E', we can choose one of two directions for the final 'A'.
2)

{"ABC",
 "DEF",
 "GHI"}
"ABCD"
Returns: 0
We can trace a path for "ABC", but there's no way to complete a path to the letter 'D'.
3)

{"AA",
 "AA"}
"AAAA"
Returns: 108
We can start from any of the four locations. From each location, we can then move in any of the three possible directions for our second letter, and again for the third and fourth letter. 4 * 3 * 3 * 3 = 108.
4)

{"ABABA",
 "BABAB",
 "ABABA",
 "BABAB",
 "ABABA"}
"ABABABBA"
Returns: 56448
There are a lot of ways to trace this path.
5)

{"AAAAA",
 "AAAAA",
 "AAAAA",
 "AAAAA",
 "AAAAA"}
"AAAAAAAAAAA"
Returns: -1
There are well over 1,000,000,000 paths that can be traced.
6)

{"AB",
 "CD"}
"AA"
Returns: 0
Since we can't stay on the same cell, we can't trace the path at all.
This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2003, TopCoder, Inc. All rights reserved.
这道题大意是让你在给定的一个String数组描述的字符矩阵中，查找指定的一个字符串描述的路径的个数，矩阵中8个方向都可以移动，路径中一个字符可以出现多次，但是不能在同一个位置重复多次。如果题目理解的不太清楚，看看题目提供的几个case，应该就清楚了。
实现思路：估计我这是最笨的一个办法了。先在矩阵中查找到所有的路径的首字符的坐标位置，然后循环再每一个首字符位置开始查找路径，查找使用一个findPpath的递归方法，在当前位置的上下左右等8个方向上查找路径中的下一个字符，任何的方向找到就继续调用递归方法。当找到路径的最后一个字符时，就计数一条路径。估计也没有描述清楚，看看代码吧：

import java.util.ArrayList;
/**
 * author:zming
 * http://blog.jweb.cn
 */
public class WordPath {
 // 路径计数
 private int count = 0;
 //
 char[][] grid2;
 /**
  * @param grid
  *            矩阵数据
  * @param find
  *            路径串
  * @return 找到的路径个数
  */
 public int countPaths(String[] grid, String find) {
  char first;
  ArrayList firstPos;
  grid2 = genArr(grid);
  char[] findStr = find.toCharArray();
  first = findStr[0];
  int[] currPos = null;
  firstPos = findInitPosition(first);
  if (firstPos.size() != 0) {
   for (int i = 0; i < firstPos.size(); i++) {
    currPos = (int[]) firstPos.get(i);
    findPpath(findStr, 0, currPos);
   }
  }
  if (count > 1000000000) {
   return -1;
  } else {
   return count;
  }
 }
 /**
  *
  * @param findStr
  *            查找的路径串
  * @param pos
  *            查找串中当前字符的位置
  * @param currPos
  *            矩阵中要查找的当前前字符的坐标int[0]为x，int[1]为y
  *
  */
 private void findPpath(char[] findStr, int pos, int[] currPos) {
  char nextChar;
  int xLen, yLen, currX, currY;
  if (count > 1000000000) {
   return;
  }
  nextChar = findStr[pos + 1];
  int[] nextPos;
  yLen = grid2.length;
  xLen = grid2[0].length;
  currX = currPos[0];
  currY = currPos[1];
  /**
   * 在矩阵中从当前要找的字符开始在8个方向上查找是否有路径串中的下一个字符，
   *  在任何一个方向上如果找到了，都递归继续查找。
   */
  // up
  if (currX - 1 >= 0) {
   if (grid2[currX - 1][currY] == nextChar) {
    if (pos + 1 == findStr.length - 1) {
     count++;
    } else {
     nextPos = new int[2];
     nextPos[0] = currX - 1;
     nextPos[1] = currY;
     findPpath(findStr, pos + 1, nextPos);
    }
   }
  }
  if (currY + 1 < xLen && currX - 1 >= 0) {
   if (grid2[currX - 1][currY + 1] == nextChar) {
    if (pos + 1 == findStr.length - 1) {
     count++;
    } else {
     nextPos = new int[2];
     nextPos[0] = currX - 1;
     nextPos[1] = currY + 1;
     findPpath(findStr, pos + 1, nextPos);
    }
   }
  }
  // right
  if (currY + 1 < xLen) {
   if (grid2[currX][currY + 1] == nextChar) {
    if (pos + 1 == findStr.length - 1) {
     count++;
    } else {
     nextPos = new int[2];
     nextPos[0] = currX;
     nextPos[1] = currY + 1;
     findPpath(findStr, pos + 1, nextPos);
    }
   }
  }
  if (currX + 1 < xLen && currY + 1 < yLen) {
   if (grid2[currX + 1][currY + 1] == nextChar) {
    if (pos + 1 == findStr.length - 1) {
     count++;
    } else {
     nextPos = new int[2];
     nextPos[0] = currX + 1;
     nextPos[1] = currY + 1;
     findPpath(findStr, pos + 1, nextPos);
    }
   }
  }
  // down
  if (currX + 1 < yLen) {
   if (grid2[currX + 1][currY] == nextChar) {
    if (pos + 1 == findStr.length - 1) {
     count++;
    } else {
     nextPos = new int[2];
     nextPos[0] = currX + 1;
     nextPos[1] = currY;
     findPpath(findStr, pos + 1, nextPos);
    }
   }
  }
  if (currY - 1 >= 0 && currX + 1 < yLen) {
   if (grid2[currX + 1][currY - 1] == nextChar) {
    if (pos + 1 == findStr.length - 1) {
     count++;
    } else {
     nextPos = new int[2];
     nextPos[0] = currY - 1;
     nextPos[1] = currX + 1;
     findPpath(findStr, pos + 1, nextPos);
    }
   }
  }
  // left
  if (currY - 1 >= 0) {
   if (grid2[currX][currY - 1] == nextChar) {
    if (pos + 1 == findStr.length - 1) {
     count++;
    } else {
     nextPos = new int[2];
     nextPos[0] = currX;
     nextPos[1] = currY - 1;
     findPpath(findStr, pos + 1, nextPos);
    }
   }
  }
  if (currX - 1 >= 0 && currY - 1 >= 0) {
   if (grid2[currX - 1][currY - 1] == nextChar) {
    if (pos + 1 == findStr.length - 1) {
     count++;
    } else {
     nextPos = new int[2];
     nextPos[0] = currX - 1;
     nextPos[1] = currY - 1;
     findPpath(findStr, pos + 1, nextPos);
    }
   }
  }
 }
 /**
  * 在矩阵中找出所有的路径首字符的位置，以list形式返回
  *
  * @param ch
  *            路径的首字符
  * @return 矩阵中所有符合条件的坐标的数组
  */
 private ArrayList findInitPosition(char ch) {
  int[] chPos = null;
  ArrayList firstPos = new ArrayList();
  for (int i = 0; i < grid2.length; i++) {
   for (int j = 0; j < grid2[i].length; j++) {
    if (ch == grid2[i][j]) {
     chPos = new int[2];
     chPos[0] = i;
     chPos[1] = j;
     firstPos.add(chPos);
    }
   }
  }
  return firstPos;
 }
 /**
  * 将输入的一维String数组数据转换成二维的char矩阵
  *
  * @param inArr
  * @return
  */
 private char[][] genArr(String[] inArr) {
  char[][] grid = null;
  int x = 0, y = 0;
  if (inArr.length != 0) {
   x = inArr.length;
   y = inArr[0].length();
  }
  grid = new char[x][y];
  for (int i = 0; i < inArr.length; i++) {
   grid[i] = inArr[i].toCharArray();
   // for (int j = 0; j < inArr[i].length(); j++) {
   // grid[i][j] = inArr[i].substring(j, j + 1);
   // }
  }
  return grid;
 }
 public static void main(String[] args) {
  WordPath wp = new WordPath();
  // String[] inArr = { "ABC", "FED", "GHI" };
  // String find = "ABCDEFGHI";
  // String[] inArr = {"ABC",
  // "FED",
  // "GAI"};
  // String find = "ABCDEA";
  // String[] inArr = {"AA",
  // "AA"};
  // String find = "AAAA";
  // String[] inArr = {"AB"};
  // String find = "ABA";
  //  
  String[] inArr = { "ABABA", "BABAB", "ABABA", "BABAB", "ABABA" };
  String find = "ABABABBA";
  // String[] inArr = { "AAAAA", "AAAAA", "AAAAA", "AAAAA", "AAAAA" };
  // String find = "AAAAAAAAAAA";
  System.out.println("Path count:" + wp.countPaths(inArr, find));
 }
}