[LeetCode] Word Ladder II

Given two words (start and end), and a dictionary, find all shortest transformation sequence(s) from start to end, such that:

1. Only one letter can be changed at a time
2. Each intermediate word must exist in the dictionary

For example,

Given:
start = "hit"
end = "cog"
dict = ["hot","dot","dog","lot","log"]

Return

  [
    ["hit","hot","dot","dog","cog"],
    ["hit","hot","lot","log","cog"]
  ]

Note:

• All words have the same length.
• All words contain only lowercase alphabetic characters.

这题做得真累，尝试了几种不同的解法，感觉一不小心就会超时了。

这题很明显和上一题一样，仍然应该使用BFS，关键是要保存所有的最短路径而非单个最短距离。如何保存呢？这里我使用了两种不同的思路。

思路1：自定义一个Node类，里面保存当前节点的所有前驱，然后再用DFS去从end到start递推获得所有路径。

思路2：使用Set>。虽然结果需要的形式为List>，可以先用Set保存各个路径来达到去重的目的，然后调用容器类的addAll方法即可。

和上一题比较不同的是，当前str为一个字典词，且也在map里时，需要进一步判断：如果这条路径的长度和当前所保存的路径长度相等，那么也应该把当前路径加入到路径集合中。但是这里不能把这个str再次加入到搜索队列，因为这个str已经出现在map中了，说明之前肯定已经搜索到了，在第一次搜索到的时候已经加入到了搜索队列中。如果再次加入搜索队列，则会导致重复搜索而超时。

思路1实现：

	public class Node {
		public int dist;
		public String str;
		public LinkedList prev;

		public Node(int dist, String str) {
			this.dist = dist;
			this.str = str;
			this.prev = new LinkedList();
		}

		public void addPrev(Node pNode) {
			prev.add(pNode);
		}
	}

	public List> findLadders(String start, String end,
			Set dict) {
		dict.add(end);

		// Key: the dictionary string; Value: Node.
		Map map = new HashMap();
		Queue queue = new LinkedList();

		Node startNode = new Node(1, start);
		queue.offer(start);
		map.put(start, startNode);

		List> ret = new ArrayList>();

		while (!queue.isEmpty()) {
			String str = queue.poll();

			if (str.equals(end)) {
				getPaths(map.get(end), map, new ArrayList(), ret);
				return ret;
			}

			for (int i = 0; i < str.length(); i++) {
				for (int j = 0; j < 26; j++) {
					char c = (char) ('a' + j);
					String newStr = replace(str, i, c);

					// If a new word is explored.
					if (dict.contains(newStr)) {
						if (!map.containsKey(newStr)) {
							// Construct a new node.
							Node node = map.get(str);
							Node newNode = new Node(node.dist + 1, newStr);
							newNode.prev = new LinkedList();
							newNode.prev.add(node);

							map.put(newStr, newNode);
							queue.offer(newStr);
						} else {
							Node node = map.get(newStr);
							Node prevNode = map.get(str);

							// Increase the path set.
							if (node.dist == prevNode.dist + 1) {
								node.addPrev(prevNode);
								// queue.offer(newStr); // This will cause TLE.
							}
						}
					}
				}
			}
		}

		return ret; // Return an empty set.
	}

思路2实现：

	public List> findLadders(String start, String end,
			Set dict) {
		dict.add(end);

		// Key: the dictionary string; Value: Set>.
		Map>> map = new HashMap>>();
		Queue queue = new LinkedList();

		List startPath = new ArrayList();
		startPath.add(start);
		Set> startSet = new HashSet>();
		startSet.add(startPath);
		queue.offer(start);
		map.put(start, startSet);

		List> ret = new ArrayList>();

		while (!queue.isEmpty()) {
			String str = queue.poll();

			if (str.equals(end)) {
				ret.addAll(map.get(end));
				return ret;
			}

			for (int i = 0; i < str.length(); i++) {
				for (int j = 0; j < 26; j++) {
					// Transform it into another word.
					String newStr = replace(str, i, (char) ('a' + j));

					// If a new word is explored.
					if (dict.contains(newStr)) {
						if (!map.containsKey(newStr)) {
							// Construct a new path set.
							Set> prevSet = map.get(str);
							Set> newSet = new HashSet>();
							for (List path : prevSet) {
								List newPath = new ArrayList(
										path);
								newPath.add(newStr);
								newSet.add(newPath);
							}

							map.put(newStr, newSet);
							queue.offer(newStr);
						} else {
							Set> prevSet = map.get(str);
							Set> newSet = map.get(newStr);

							Iterator> prevIt = prevSet.iterator();
							Iterator> newIt = newSet.iterator();

							// Increase the path set.
							if (prevIt.next().size() + 1 == newIt.next().size()) {
								for (List path : prevSet) {
									List newPath = new ArrayList(
											path);
									newPath.add(newStr);
									newSet.add(newPath);
									// queue.offer(newStr); // This will cause TLE.
								}
							}
						}
					}
				}
			}
		}

		return ret; // Return an empty set.
	}

	// Replace a character at the given index of str, with c.
	private String replace(String str, int index, char c) {
		StringBuilder sb = new StringBuilder(str);
		sb.setCharAt(index, c);
		return sb.toString();
	}

思路2由于不需要使用DFS去还原重构所求路径，也不需要自定义类，所以代码会稍微简短点。但是频繁的对中间结果路径的拷贝导致效率相对偏低，思路一会更快一点。

另外有一段代码是两个思路都需要的实现的一个子函数，用于还原路径。

	// Get all the paths by using DFS.
	private void getPaths(Node end, Map map,
			List curPath, List> paths) {
		if (end == null) {
			paths.add(curPath);
			return;
		}

		curPath.add(0, end.str);
		if (!end.prev.isEmpty()) {
			for (Node prevNode : end.prev) {
				getPaths(prevNode, map, new ArrayList(curPath), paths);
			}
		} else {
			getPaths(null, map, curPath, paths);
		}
	}