hdu 1026 Ignatius and the Princess I

import java.util.Comparator;
import java.util.Queue;
import java.util.Scanner;
import java.util.PriorityQueue;

public class Main {
	/*
	 * n表示行
	 * m表示列
	 * nodes，记录每一个结点
	 * Node用来保存地图数据与其他变量的
	 * isFind判断英雄是否可以到达目的地
	 * dir记录四个方向,分别为上下左右，
	 * 这个初学者是会搞错的。
	 * --{a,b}，a表示行,b表示列
	 */
	static int n = 0;
	static int m = 0;
	static Node[][] nodes = new Node[101][101];
	static boolean isFind;
	static int dir[][] = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };

	/*
	 * java是极其耗内存的， 
	 * 所以我只用101*101个对象
	 */
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		for (int i = 0; i < nodes.length; i++) {
			for (int j = 0; j < nodes[0].length; j++) {
				nodes[i][j] = new Node();
			}
		}
		while (sc.hasNext()) {
			n = sc.nextInt();
			m = sc.nextInt();
			for (int i = 0; i < n; i++) {
				String str = sc.next();
				for (int j = 0; j < m; j++) {
					/* 
					 * 每次都初始化数据
					 * 每个结点初始化步数为-1，
					 * 因为要是第一个结点往下步行动，
					 * 那么他的邻接点要小于他的步数，
					 * 也就是时间。
					 */
					nodes[i][j].set(i, j, str.charAt(j), Integer.MAX_VALUE,
							null);
				}
			}
			/*
			 * isFind初始认为英雄不能到达目的地
			 */
			isFind = false;
			breadthFirstSearch();
			if (isFind) {
				System.out
						.println("It takes "
								+ nodes[n - 1][m - 1].time
								+ " seconds to reach the target position, let me show you the way.");
				printAnswer(nodes[n - 1][m - 1]);
			} else {
				System.out.println("God please help our poor hero.");
			}
			System.out.println("FINISH");
		}
	}

	/*
	 * 这道题，答案的输出其实要用到树的知识，
	 * 因为我纪录的一条最短路，只要从根节点找到父节点，
	 * 就可以输出答案了。
	 * 这个要逆序输出，
	 * 那么就用递归输出把！
	 */
	private static void printAnswer(Node nod) {
		/*
		 * 1）鸿沟
		 * 2）递归
		 * 3）回退
		 */
		if (nod.parent == null) {
			return;
		}
		printAnswer(nod.parent);
		if (nod.time - nod.parent.time == 1) {
			System.out.println(nod.time + "s:(" + nod.parent.x + ","
					+ nod.parent.y + ")->(" + nod.x + "," + nod.y + ")");
		} else {
			System.out.println(nod.parent.time + 1 + "s:(" + nod.parent.x + ","
					+ nod.parent.y + ")->(" + nod.x + "," + nod.y + ")");
			for (int i = nod.parent.time + 2; i <= nod.time; i++) {
				System.out.println(i + "s:FIGHT AT (" + nod.x + "," + nod.y
						+ ")");
			}
		}

	}

	/*
	 * breadthFirstSearch-广度优先搜索 
	 * 这题使用优先队列+广度优先搜索做
	 */
	private static void breadthFirstSearch() {
		/*
		 * 入口是搜索源，
		 * 起点的初始时间为0。
		 * 这里只要引用就行，不要深拷贝
		 * PriorityQueue-优先队列，节约内存
		 * 把搜索源加入队列
		 */
		nodes[0][0].time = 0;
		Queue<Node> priQue = new PriorityQueue<Node>(100, new MyComparator());
		priQue.add(nodes[0][0]);
		while (!priQue.isEmpty()) {
			/*
			 * 优先弹出最小的time值的结点
			 * 这个队列是自己写的，感觉用的比较爽。
			 * 搜索四个方向，
			 * 剪枝。
			 */
			Node no = priQue.poll();
			int i = no.x;
			int j = no.y;
			/*
			 * 到达出口,就需要回退，
			 * 只要所有的元素都出队列了，
			 * 那么就可以把最短路径纪录了。
			 */
			if (i == n - 1 && j == m - 1) {
				/*
				 * 纪录时间，每一次进入这条语句，
				 * 都表明时间更快，不可能慢，或则快。
				 * 如果进不来就表明无法到达终点。
				 */
				isFind = true;
				return;
			}
			for (int k = 0; k < 4; k++) {
				i = no.x + dir[k][0];
				j = no.y + dir[k][1];
				// 越界
				if (i < 0 || j < 0 || i >= n || j >= m) {
					continue;
				}
				// 碰到障碍
				if (nodes[i][j].ch == 'X') {
					continue;
				}
				/*
				 * 这题是可以重复落脚的。
				 * 重要剪枝，
				 * 如果下次落脚点的时间小于原先的，
				 * 就可以落脚。
				 * 如果大于等于，那么就不可以落脚，
				 * 初始化时应该把值赋值为最大的数。
				 */
				if (nodes[i][j].time <= no.time) {
					continue;
				}
				/*
				 * 搜索到可行的结点，
				 * 复制时间，且加1，
				 * 纪录父节点，
				 * 并且该节点被标记为，已被访问。
				 * 把搜索到的结点加入队列。
				 */
				// 遇到小怪
				nodes[i][j].time = no.time + 1;
				if (nodes[i][j].ch <= '9' && nodes[i][j].ch >= '1') {
					nodes[i][j].time += (int) (nodes[i][j].ch - '0');
				}
				nodes[i][j].parent = no;
				priQue.add(nodes[i][j]);
			}
		}
	}
}

class Node {
	int x;
	int y;
	char ch;
	int time;
	Node parent;

	public Node() {
	}

	public void set(int x, int y, char ch, int time, Node parent) {
		this.x = x;
		this.y = y;
		this.ch = ch;
		this.time = time;
		this.parent = parent;
	}

}

class MyComparator implements Comparator<Node> {

	public int compare(Node n1, Node n2) {
		if (n1.time > n2.time) {
			return 1;
		} else if (n1.time < n2.time) {
			return -1;
		} else {
			return 0;
		}
	}

}

Ignatius and the Princess I