开关问题（高斯消元）

B. 开关问题

Time Limit: 1000ms

Memory Limit: 30000KB

64-bit integer IO format: %lld      Java class name: Main

有N个相同的开关，每个开关都与某些开关有着联系，每当你打开或者关闭某个开关的时候，其他的与此开关相关联的开关也会相应地发生变化，即这些相联系的开关的状态如果原来为开就变为关，如果为关就变为开。你的目标是经过若干次开关操作后使得最后N个开关达到一个特定的状态。对于任意一个开关，最多只能进行一次开关操作。你的任务是，计算有多少种可以达到指定状态的方法。（不计开关操作的顺序）

Input

输入第一行有一个数K，表示以下有K组测试数据。
每组测试数据的格式如下：
第一行 一个数N（0 < N < 29）
第二行 N个0或者1的数，表示开始时N个开关状态。
第三行 N个0或者1的数，表示操作结束后N个开关的状态。
接下来 每行两个数I J，表示如果操作第 I 个开关，第J个开关的状态也会变化。每组数据以 0 0 结束。

Output

如果有可行方法，输出总数，否则输出“Oh,it's impossible~!!” 不包括引号

Sample Input

2
3
0 0 0
1 1 1
1 2
1 3
2 1
2 3
3 1
3 2
0 0
3
0 0 0
1 0 1
1 2
2 1
0 0

Sample Output

4
Oh,it's impossible~!!

Hint

第一组数据的说明：
一共以下四种方法：
操作开关1
操作开关2
操作开关3
操作开关1、2、3 （不记顺序）

    #include <iostream>
    #include <cstdio>
    #include <cstring>
    #include <algorithm>
    using namespace std;
    #define MAXN 50
    int a[MAXN], e[MAXN];
    int n;

    void swap(int &a,int &b){
        int t = a;
        a = b;
        b = t;
    }

    struct Matrix{
        int mp[MAXN][MAXN];
        void rswap(int x,int y){//将x行的元素与y行的元素互换
            for(int j = 1; j <= n+1; j++){
                swap(mp[x][j],mp[y][j]);
            }
        }
        void relax(int x, int y){//用x行的元素消掉y行的元素，一般为第一个非零元
            for(int j = 1; j <= n+1; j ++){
                mp[y][j] ^= mp[x][j];
            }
        }
        void init(){//初始化
            memset(mp,0,sizeof(mp));
            for(int i = 1; i <= n ;i++){//自己可以改变自己
                mp[i][i] = 1;
            }
        }
    }M;

    void Gauss(){
        int i, j, k, ptr;
        for(i = 1, j= 1; j <= n; ++i, ++j){//形成行阶梯型矩阵，从第一行第一列开始，逐列递增
            for(ptr = i; ptr  <= n ; ptr++){//找出第一个是非零元的行
                if(M.mp[ptr][j]){
                    break;
                }
            }
            if(ptr == n+1){//如果这一列所有行都是零元，则跳过这一列
                --i;
                continue;
            }
            if(ptr != i){//如果第一个是非零元的行不是当前行，则与其互换位置
                M.rswap(ptr,i);
            }
            for(k = i+1; k <= n; k++ ){//用当前的行当前列的值对下面所有行当前列的值进行消除，使其为0，以满足行阶梯型
                if(!M.mp[k][j]){//如果是0，则跳过
                    continue;
                }
                M.relax(i,k);//不是，则消除。
            }
        }
        for( k = i; k <= n; k++){//处理完所有列（为n，n+1为答案列不用计算）之后，也就是现在mp数组就是行阶梯型了，那么看零行的答案是否都为0，有不为0，即是无解。
            if(M.mp[k][n+1] != 0){
                printf("Oh,it's impossible~!!\n");
                return ;
            }
        }

        printf("%d\n",1<<(n-i+1));//有多少零行就有多少自由元，输出结果
        return;
    }


    int main() {
        int Case , s, t;
        s =  1; t = 2;
        swap(s,t);
        scanf("%d",&Case);
        while(Case--){
            scanf("%d",&n);
            M.init();//初始化矩阵
            for(int i = 1; i <= n; i++){//初始状态读入
                scanf("%d",&a[i]);
            }
            for(int i = 1; i <= n; i++){//终止状态读入
                scanf("%d",&e[i]);
                M.mp[i][n+1] = a[i] ^ e[i];//增广矩阵
            }
            while(scanf("%d%d",&s,&t),s|t){//相互影响的开关读入
                M.mp[t][s] = 1;
            }
            Gauss();
        }
        return 0;
    }