使用java语言解决以下编程问题：你玩过“拉灯”游戏吗？ 25 盏灯排成一个 5×5 的方形。 每一个灯都有一个开关，游戏者可以改变它的状态。 每一步，游戏者可以改变某一个灯的状态。 游戏者改变一个灯的状态会产生连锁反应：和这个灯上下左右相邻的灯也要相应地改变其状态。 我们用数字 1 表示一盏开着的灯，用数字 0 表示关着的灯。 下面这种状态 10111 01101 10111 10000 11011 在改变了最左上角的灯的状态后将变成： 01111 11101 10111 10000 11011 再改变它正中间的灯后状态将变成： 01111 11001 11001 10100 11011 给定一些游戏的初始状态，编写程序判断游戏者是否可能在 6 步以内使所有的灯都变亮。 输入格式 第一行输入正整数 n ，代表数据中共有 n 个待解决的游戏初始状态。 以下若干行数据分为 n 组，每组数据有 5 行，每行 5 个字符。 每组数据描述了一个游戏的初始状态。 各组数据间用一个空行分隔。 输出格式 一共输出 n 行数据，每行有一个小于等于 6 的整数，它表示对于输入数据中对应的游戏状态最少需要几步才能使所有灯变亮。 对于某一个游戏初始状态，若 6 步以内无法使所有灯变亮，则输出 −1 。 数据范围 0<n≤500 输入样例： 3 00111 01011 10001 11010 11100 11101 11101 11110 11111 11111 01111 11111 11111 11111 11111 输出样例： 3 2 -1

这个问题可以使用广度优先搜索（BFS）来解决。我们可以将每一个游戏状态看作图的一个节点，如果两个游戏状态可以通过改变一个灯的状态相互转换，那么它们之间存在一条边。

首先，我们需要定义游戏状态的数据结构。可以使用一个二维数组来表示游戏状态，其中 0 表示灯关着，1 表示灯开着。然后，我们可以使用一个队列来进行广度优先搜索，将初始状态加入队列。

在每一步中，我们从队列中取出一个游戏状态，然后尝试改变每一个灯的状态，将新的游戏状态加入队列。同时，我们需要记录每个游戏状态所需要的步数。

最后，我们可以得到所有游戏状态所需要的最少步数。

以下是解决该问题的 Java 代码：

import java.util.*;

public class Main {
    static class GameState {
        int[][] state;
        int steps;

        public GameState(int[][] state, int steps) {
            this.state = state;
            this.steps = steps;
        }
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();

        while (n-- > 0) {
            // 读取游戏初始状态
            int[][] initialState = new int[5][5];
            for (int i = 0; i < 5; i++) {
                String line = in.next();
                for (int j = 0; j < 5; j++) {
                    initialState[i][j] = line.charAt(j) - '0';
                }
            }

            int result = solve(initialState);
            System.out.println(result);
        }
    }

    private static int solve(int[][] initialState) {
        // 全部灯都亮的状态
        int[][] targetState = new int[5][5];
        for (int i = 0; i < 5; i++) {
            Arrays.fill(targetState[i], 1);
        }

        Queue<GameState> queue = new LinkedList<>();
        Set<String> visited = new HashSet<>();

        // 添加初始状态
        GameState initState = new GameState(initialState, 0);
        queue.offer(initState);
        visited.add(getStateString(initialState));

        while (!queue.isEmpty()) {
            GameState currentState = queue.poll();
            int[][] state = currentState.state;
            int steps = currentState.steps;

            // 判断是否达到目标状态
            if (Arrays.deepEquals(state, targetState)) {
                return steps;
            }

            // 尝试改变每一个灯的状态
            for (int i = 0; i < 5; i++) {
                for (int j = 0; j < 5; j++) {
                    int[][] newState = flipLight(state, i, j);
                    String newStateString = getStateString(newState);

                    if (!visited.contains(newStateString)) {
                        GameState nextState = new GameState(newState, steps + 1);
                        queue.offer(nextState);
                        visited.add(newStateString);
                    }
                }
            }
        }

        return -1;
    }

    private static int[][] flipLight(int[][] state, int row, int col) {
        int[][] newState = new int[5][5];
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                newState[i][j] = state[i][j];
            }
        }

        newState[row][col] ^= 1;
        if (row - 1 >= 0) newState[row - 1][col] ^= 1;
        if (row + 1 < 5) newState[row + 1][col] ^= 1;
        if (col - 1 >= 0) newState[row][col - 1] ^= 1;
        if (col + 1 < 5) newState[row][col + 1] ^= 1;

        return newState;
    }

    private static String getStateString(int[][] state) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                sb.append(state[i][j]);
            }
        }
        return sb.toString();
    }
}

首先，我们定义了一个内部类 `GameState`，用于表示游戏状态。它包含一个二维数组 `state` 表示游戏状态，以及一个整数 `steps` 表示到达该状态所需要的步数。

在 `solve` 方法中，我们使用一个队列 `queue` 来存储待处理的游戏状态。我们还使用一个集合 `visited` 来记录已经访问过的游戏状态，避免重复处理。

我们首先将初始状态加入队列，并标记为已访问。然后，在每一步中，我们从队列中取出一个游戏状态，并尝试改变每一个灯的状态，生成新的游戏状态。如果新的游戏状态没有被访问过，则将其加入队列，并更新到达该状态所需要的步数。

最后，我们判断是否存在达到全部灯都亮的目标状态，如果存在，则返回所需要的步数；否则，返回 -1。

这样，我们就可以解决该问题，并得到每个游戏状态所需要的最少步数。