[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<String>>。虽然结果需要的形式为List<List<String>>，可以先用Set保存各个路径来达到去重的目的，然后调用容器类的addAll方法即可。

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

思路1实现：

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

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

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

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

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

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

		List<List<String>> ret = new ArrayList<List<String>>();

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

			if (str.equals(end)) {
				getPaths(map.get(end), map, new ArrayList<String>(), 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<Node>();
							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<List<String>> findLadders(String start, String end,
			Set<String> dict) {
		dict.add(end);

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

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

		List<List<String>> ret = new ArrayList<List<String>>();

		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<List<String>> prevSet = map.get(str);
							Set<List<String>> newSet = new HashSet<List<String>>();
							for (List<String> path : prevSet) {
								List<String> newPath = new ArrayList<String>(
										path);
								newPath.add(newStr);
								newSet.add(newPath);
							}

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

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

							// Increase the path set.
							if (prevIt.next().size() + 1 == newIt.next().size()) {
								for (List<String> path : prevSet) {
									List<String> newPath = new ArrayList<String>(
											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<String, Node> map,
			List<String> curPath, List<List<String>> 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<String>(curPath), paths);
			}
		} else {
			getPaths(null, map, curPath, paths);
		}
	}