Given two words (
start and
end), and a dictionary, find all shortest transformation sequence(s) from
start to
end, such that:
- Only one letter can be changed at a time
- 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方法时,根据已扩展的结束和当前结点,求出当前结点可以扩展出的结点,并将扩展出的结点的前驱结点记录下来,便于后面计算出变换路径;用SPFA算法时,也是用的队列,但是可以重复入队列,在路径值相等时,将当前结点加入到扩展结点的父结点数组中
bfs方法代码如下
public class Solution {
private List<String> possibleNode(String cur, String end, Set<String> dict, Set<String> visited)
{
List<String> res = new ArrayList<String>();
for (int i = 0; i < cur.length(); i++) {
char[] ar = cur.toCharArray();
for (char j = 'a'; j <= 'z'; j++) {
ar[i] = j;
String tmp = new String(ar);
if (dict.contains(tmp) && !visited.contains(tmp)) res.add(tmp);
}
}
if (res.contains(end)) {
res = new ArrayList<String>();
res.add(end);
}
return res;
}
private List<List<String>> buildPaths(String start, String end, Map<String, Map<Integer, Set<String>>> parent)
{
List<List<String>> res = new ArrayList<List<String>>();
Set<String> prevsteps = null;
if (parent.containsKey(end)) {
//获取上一层的字符串,i是按递增序访问的
for (int i : parent.get(end).keySet()) {
prevsteps = parent.get(end).get(i);
}
}
if (prevsteps == null) {
if (start.equals(end)) {
List<String> path = new ArrayList<String>();
path.add(end);
res.add(path);
}
return res;
}
if (prevsteps.size() == 0) {
List<String> path = new ArrayList<String>();
path.add(end);
res.add(path);
} else {
for (String s : prevsteps) {
List<List<String>> path = buildPaths(start, s, parent);
for (List<String> p : path) {
p.add(end);
res.add(p);
}
}
}
return res;
}
public List<List<String>> findLadders(String start, String end, Set<String> dict)
{
dict.add(end);
List<List<String>> paths = new ArrayList<List<String>>();
Queue<String> tovisit = new LinkedList<String>();
Queue<Integer> level = new LinkedList<Integer>();
Set<String> visited = new HashSet<String>();
Map<String, Map<Integer, Set<String>>> parent = new HashMap<String, Map<Integer, Set<String>>>();
tovisit.add(start);
level.add(0);
parent.put(start, new HashMap<Integer, Set<String>>());
int max = Integer.MAX_VALUE;
while (!tovisit.isEmpty()) {
String current = tovisit.poll();
int curStep = level.poll();
visited.add(current);
if (curStep > max) break;
if (current.equals(end) && curStep < max) max = curStep;
else {
List<String> nodes = possibleNode(current, end, dict, visited);
for (String s : nodes) {
if (!tovisit.contains(s)) {
tovisit.add(s);
level.add(curStep + 1);
}
if (!parent.containsKey(s)) {
Map<Integer, Set<String>> levelParent = new HashMap<Integer, Set<String>>();
Set<String> parentSet = new HashSet<String>();
levelParent.put(curStep, parentSet);
parent.put(s, levelParent);
}
if (parent.get(s).containsKey(curStep)) {
parent.get(s).get(curStep).add(current);
}
}
}
}
paths = buildPaths(start, end, parent);
return paths;
}
}
SPFA代码如下
public class Solution {
private void connect(Map<String, ArrayList<String>> graph, Set<String> dict, String key)
{
graph.put(key, new ArrayList<String>());
char[] cs = key.toCharArray();
for (int i = 0, len = key.length(); i < len; i++) {
char ch = cs[i];
for (char c = 'a'; c <= 'z'; c++) {
if (cs[i] == c) continue;
cs[i] = c;
String tmp = new String(cs);
if (dict.contains(tmp)) graph.get(key).add(tmp);
}
cs[i] = ch;
}
}
private void buildGraph(Map<String, ArrayList<String>> graph, Set<String> dict, String start, String end)
{
dict.add(start);
dict.add(end);
Iterator<String> it = dict.iterator();
while (it.hasNext()) {
String key = it.next();
connect(graph, dict, key);
}
}
private void spfa(Map<String, ArrayList<String>> graph, Map<String, ArrayList<String>> path, String start)
{
Map<String, Integer> d = new HashMap<String, Integer>();
Set<String> visit = new HashSet<String>();
Queue<String> q = new LinkedList<String>();
q.offer(start);
visit.add(start);
for (String key: graph.keySet()) {
path.put(key, new ArrayList<String>());
if (key.equals(start)) d.put(key, 0);
else d.put(key, Integer.MAX_VALUE);
}
while (!q.isEmpty()) {
String cur = q.poll();
visit.remove(cur);
ArrayList<String> adjList = graph.get(cur);
for (int i = 0; i < adjList.size(); i++) {
String next = adjList.get(i);
if (d.get(next) > d.get(cur) + 1) {
d.put(next, d.get(cur) + 1);
ArrayList<String> p = new ArrayList<String>();
p.add(cur);
path.put(next, p);
if (!visit.contains(next)) {
q.offer(next);
visit.add(next);
}
} else if (d.get(next) == d.get(cur) + 1) {
path.get(next).add(cur);
}
}
}
}
private List<List<String>> buildPaths(String start, String end, Map<String, ArrayList<String>> parent)
{
List<List<String>> ans = new ArrayList<List<String>>();
if (start.equals(end)) {
List<String> p = new ArrayList<String>();
p.add(start);
ans.add(p);
return ans;
}
if (parent.containsKey(end)) {
ArrayList<String> prevs = parent.get(end);
for (String prev: prevs) {
List<List<String>> temp = buildPaths(start, prev, parent);
for (List<String> t : temp) {
t.add(end);
ans.add(t);
}
}
}
return ans;
}
public List<List<String>> findLadders(String start, String end, Set<String> dict)
{
List<List<String>> ans = new ArrayList<List<String>>();
if (start.equals(end)) {
List<String> t = new ArrayList<String>();
t.add(end);
ans.add(t);
return ans;
}
Map<String, ArrayList<String>> graph = new HashMap<String, ArrayList<String>>();
Map<String, ArrayList<String>> paths = new HashMap<String, ArrayList<String>>();
buildGraph(graph, dict, start, end);
spfa(graph, paths, start);
ans = buildPaths(start, end, paths);
return ans;
}
}