开关灯问题

开关灯问题

题目

在一个庆典上，n∗Ln * Ln∗L盏灯摆成了一个nnn行LLL列的长方形。起初，有些灯是亮的，有些灯是灭的。每列的灯是串联在一起的。一共有LLL个开关，按下第iii个开关可以改变第iii列所有灯的状态，即这一列亮的灯熄灭，熄灭的灯点亮。而且，不同的行是可以随意交换的。
主办方希望所有灯以亮或暗的不同状态组成一个图案。请你计算能否通过控制开关形成这个图案。如果可以，请计算最少按多少次开关。

输入

第一行有一个整数TTT，表示有多少组测试数据。
每组测试数据包含三行。第一行为两个整数nnn , LLL。
每组数据的第二行为nnn个长度为LLL的0/10/10/1字符串，依次描述起初每行的灯的开关状态。第iii个字符串的第jjj个字符若是’1’’1’’1’，表示对应位置的灯是亮的；’0’’0’’0’表示是灭的。
每组数据的第三行为nnn个长度为LLL的0/10/10/1字符串，描述主办方希望达到的所有灯的开关状态。格式同上。

输出

输出TTT行，依次为每组测试数据的答案。如果不可能达到，输出”Impossible””Impossible””Impossible”；否则输出最少按多少次开关。

样例输入

3
3 2
01 11 10
11 00 10
2 3
101 111
010 001
2 2
01 10
10 01

样例输出

1
Impossible
0

样例解释

第一组测试数据，按第222列开关，得到 000000 , 101010 , 111111，然后依次交换后两行和前两行即可。
第二组测试数据，可以证明不可能达到要求的方案。
第三组测试数据，只需交换两行即可。

数据范围

40% 的数据：1<=N,L<=10.
100% 的数据：1<=N<=150, 1<=L<=50, 1<=T<=4.

思路

初始状态和目标状态输入为两个二维数组，输入结束后统计每一列有多少个1，是否可以通过按开关转变为目标状态个1，如果不行立即返回，可以则对开关计次。
接下来判断是否可以通过行变换达到目标状态，把每行都视为二进制，转化为一个long，可以得到两个long的数组，对其进行排序，依次判断两组中每个数是否相等，有不相等则不行，全相等则返回开关次数。

代码

	public static void main(String[] args) {
        Scanner in = new Scanner(new BufferedInputStream(System.in));
        int T = in.nextInt();
        for (int t = 0; t < T; t++) {
            lights(in);
        }
        in.close();

    }

    public static void lights(Scanner in) {
        /**
         * 先读取输入
         * 行数多一行空 着等 后面放入这一行有多少个1
         */
        int N = in.nextInt();
        int L = in.nextInt();
        int[][] lights = new int[N + 1][L];
        for (int i = 0; i < N; i++) {
            String line = in.next();
            for (int j = 0; j < L; j++) {
                int temp = line.charAt(j) - '0';
                lights[i][j] = temp;
            }
        }
        int[][] target = new int[N + 1][L];
        for (int i = 0; i < N; i++) {
            String line = in.next();
            for (int j = 0; j < L; j++) {
                int temp = line.charAt(j) - '0';
                target[i][j] = temp;
            }
        }
        /**
         * END 输入读取
         */

        //添加纵列信息（在每一列最后一行添加这一列一共有多少个1）
        for (int j = 0; j < L; j++) {
            int trueNum = 0, tarTrueNum = 0;
            for (int i = 0; i < N; i++) {
                if (lights[i][j] == 1) {
                    trueNum++;
                }
                if (target[i][j] == 1) {
                    tarTrueNum++;
                }
            }
            lights[N][j] = trueNum;
            target[N][j] = tarTrueNum;
        }
        //开关次数
        int times = 0;
        /**
         * 通过比较每一列最后一行的信息（即此列有多少个一来判断是否可以通过开关灯实现）
         * 有相同个数1或者 1与目标0个数相同（按开关） 即可行，均不满足则不可能
         * 在比较过程中把需要按开关的列都按下开关
         */
        for (int i = 0; i < L; i++) {
            //有列不满足则直接返回
            if (lights[N][i] != target[N][i] && lights[N][i] != (N - target[N][i])) {
                System.out.println("Impossible");
                return;
            }
            //有需要按开关的则按开关，并对开关计次
            if (lights[N][i] != target[N][i] && lights[N][i] == (N - target[N][i])) {
                //对开关计次
                times++;
                //对值异或1使其反转
                for (int j = 0; j < N; j++) {
                    lights[j][i] ^= 1;
                }
            }
        }
        //再看横向，把横向一个数组转化成一个字符串 如”010010“
        String[] sLights = new String[N];
        String[] sTarget = new String[N];
        for (int i = 0; i < N; i++) {
            StringBuffer b1 = new StringBuffer();
            StringBuffer b2 = new StringBuffer();
            for (int j = 0; j < L; j++) {
                b1.append(String.valueOf(lights[i][j]));
                b2.append(String.valueOf(target[i][j]));
            }
            sLights[i] = b1.toString();
            sTarget[i] = b2.toString();
        }

        //再把字符串看成二进制转化为long（因为最多有50个数，超过了int的范围，只能用long）
        long[] lLights = new long[N];
        long[] lTarget = new long[N];
        for (int i = 0; i < N; i++) {
            lLights[i] = Long.valueOf(sLights[i], 2);
            lTarget[i] = Long.valueOf(sTarget[i], 2);
        }

        //对两个long的数组排序
        Arrays.sort(lLights);
        Arrays.sort(lTarget);

        //挨个比较long的值，如果有不等则返回，全相等则输出按开关的次数
        for (int i = 0; i < N; i++) {
            if (lLights[i] != lTarget[i]) {
                System.out.println("Impossible");
                return;
            }
        }
        System.out.println(times);
        return;

    }