打开转盘锁

/*
 * 思路：
 * 1. 使用广度优先搜索（BFS）算法来解决这个问题。
 * 2. 从起始状态 "0000" 开始，通过每次旋转拨轮生成新的状态。
 * 3. 使用一个队列来存储当前状态和步数。
 * 4. 使用一个集合来存储死亡数字和已访问的状态，避免重复访问。
 * 5. 如果当前状态是目标状态，返回步数。
 * 6. 如果遍历完所有可能的状态仍未找到目标状态，返回 -1。
 * 7. 使用Java Stream来简化代码。
 */
import java.util.*;
import java.util.stream.*;

public class OpenLockStream {
    public int openLock(String[] deadends, String target) {
        Set<String> dead = Arrays.stream(deadends).collect(Collectors.toSet());
        Set<String> visited = new HashSet<>();
        Queue<String> queue = new LinkedList<>();
        queue.offer("0000");
        visited.add("0000");
        int steps = 0;

        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                String current = queue.poll();
                if (dead.contains(current)) {
                    continue;
                }
                if (current.equals(target)) {
                    return steps;
                }
                getNextStates(current).stream()
                    .filter(next -> !visited.contains(next))
                    .forEach(next -> {
                        queue.offer(next);
                        visited.add(next);
                    });
            }
            steps++;
        }
        return -1;
    }

    private List<String> getNextStates(String state) {
        return IntStream.range(0, 4).boxed()
            .flatMap(i -> Stream.of(
                new StringBuilder(state).replace(i, i + 1, String.valueOf((state.charAt(i) - '0' + 1) % 10)).toString(),
                new StringBuilder(state).replace(i, i + 1, String.valueOf((state.charAt(i) - '0' + 9) % 10)).toString()
            ))
            .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        OpenLockStream solution = new OpenLockStream();
        String[] deadends = {"0201", "0101", "0102", "1212", "2002"};
        String target = "0202";
        System.out.println(solution.openLock(deadends, target)); // 输出: 6
    }
}