feate: 字符串接龙 Java优化版并修复存在问题

1.使用null标志分层
2.寻找邻接节点时，回滚修改，避免多次数组复制
3.修复边界条件：beginStr==endStr时，应该输出0；

problems/kamacoder/0110.字符串接龙.md

@@ -153,64 +153,68 @@ int main() {
 ## 其他语言版本
 
 ### Java
+
 ```Java
+import java.util.*;
+
 public class Main {
-    // BFS方法
-    public static int ladderLength(String beginWord, String endWord, List<String> wordList) {
-        // 使用set作为查询容器，效率更高
-        HashSet<String> set = new HashSet<>(wordList);
-        
-        // 声明一个queue存储每次变更一个字符得到的且存在于容器中的新字符串
-        Queue<String> queue = new LinkedList<>();
-        
-        // 声明一个hashMap存储遍历到的字符串以及所走过的路径path
-        HashMap<String, Integer> visitMap = new HashMap<>();
-        queue.offer(beginWord);
-        visitMap.put(beginWord, 1);
-        
-        while (!queue.isEmpty()) {
-            String curWord = queue.poll();
-            int path = visitMap.get(curWord);
-
-            for (int i = 0; i < curWord.length(); i++) {
-                char[] ch = curWord.toCharArray();
-                // 每个位置尝试26个字母
-                for (char k = 'a'; k <= 'z'; k++) {
-                    ch[i] = k;
-
-                    String newWord = new String(ch);
-                    if (newWord.equals(endWord)) return path + 1;
-                    
-                    // 如果这个新字符串存在于容器且之前未被访问到
-                    if (set.contains(newWord) && !visitMap.containsKey(newWord)) {
-                        visitMap.put(newWord, path + 1);
-                        queue.offer(newWord);
-                    }
-                }
-            }
-        }
-
-        return 0;
-    }
-    
     public static void main(String[] args) {
-        /* code */
+        Scanner scanner = new Scanner(System.in);
-        // 接收输入
+        int n = scanner.nextInt();
-        Scanner sc = new Scanner(System.in);
+        scanner.nextLine();
-        int N = sc.nextInt();
+        String beginStr = scanner.next();
-        sc.nextLine();
+        String endStr = scanner.next();
-        String[] strs = sc.nextLine().split(" ");
+        scanner.nextLine();
-        
         List<String> wordList = new ArrayList<>();
-        for (int i = 0; i < N; i++) {
+        wordList.add(beginStr);
-            wordList.add(sc.nextLine());
+        wordList.add(endStr);
+        for (int i = 0; i < n; i++) {
+            wordList.add(scanner.nextLine());
+        }
+        int count = bfs(beginStr, endStr, wordList);
+        System.out.println(count);
     }
 
-        // wordList.add(strs[1]);
+    /**
-        
+     * 广度优先搜索-寻找最短路径
-        // 打印结果
+     */
-        int result = ladderLength(strs[0], strs[1], wordList);
+    public static int bfs(String beginStr, String endStr, List<String> wordList) {
-        System.out.println(result);
+        int len = 1;
+        Set<String> set = new HashSet<>(wordList);
+        Set<String> visited = new HashSet<>();
+        Queue<String> q = new LinkedList<>();
+        visited.add(beginStr);
+        q.add(beginStr);
+        q.add(null);
+        while (!q.isEmpty()) {
+            String node = q.remove();
+            //上一层结束，若下一层还有节点进入下一层
+            if (node == null) {
+                if (!q.isEmpty()) {
+                    len++;
+                    q.add(null);
+                }
+                continue;
+            }
+            char[] charArray = node.toCharArray();
+            //寻找邻接节点
+            for (int i = 0; i < charArray.length; i++) {
+                //记录旧值，用于回滚修改
+                char old = charArray[i];
+                for (char j = 'a'; j <= 'z'; j++) {
+                    charArray[i] = j;
+                    String newWord = new String(charArray);
+                    if (set.contains(newWord) && !visited.contains(newWord)) {
+                        q.add(newWord);
+                        visited.add(newWord);
+                        //找到结尾
+                        if (newWord.equals(endStr)) return len + 1;
+                    }
+                }
+                charArray[i] = old;
+            }
+        }
+        return 0;
     }
 }