ACdream群OJ 1217 Cracking' RSA（ASC#1）高斯消元、行列式的秩

【题目大意】

给m个数字，保证每个数字的质因子都是前t个质数中的一些。从m个数字中选若干个数组成一个集合，求，有多少个非空集合，集合内每个数字相乘是一个完全平方数。

【思路】

首先，对每个数质因子分解，如果其某个因子的个数可以等价地看做个数%2。比方，数字9可以看做数字1，数字20可以看做数字5。

如果我们设xi表示是否选择第i个数字（0/1），可以列出只有位运算的方程组。这个不好说，我举个列吧。就样例来说。

上表是每个数的因子个数等价情况。可以列出如下方程组。

2： （0&x1）^（0&x2）^（0&x3）^（0&x4）== 0

3： （0&x1）^（0&x2）^（0&x3）^（1&x4）== 0

5： （0&x1）^（1&x2）^（1&x3）^（0&x4）== 0

每个方程什么意思呢？比方，xi全为1（所有数字都选），其乘积，质因子3的个数的奇偶性对应的上面方程中的”3：（0&x1）^（0&x2）^（0&x3）^（1&x4）== 0“，大概意思可以表述为：选了b1（9），乘积质因子3的个数会+0；选了b2（20），乘积质因子3的个数会+0；选了b3（500），乘积质因子2的个数会+0；选了b4（3），乘积质因子2的个数会+1；其最终的奇偶性，就是异或和。如果是完全平方数，奇偶性质当然是偶。所以，方程的一个解，对应一个合法的集团。

那么，剩下的问题就是怎么去求这个方程组的解的个数。其实解的个数 == 2^（m-行列式的秩）  - 1。

我们假设t == m-行列式的秩，如果我们确定了最后t个xi的0/1情况，再去线性变化行列式，会发现这变成了一个满秩矩阵（满秩矩阵有且仅有一个解）。那么就是确定的最后t个xi的情况，解就唯一了。因为是0/1，答案是2^t，减去空集，就是2^t - 1。

而，具体这个方程组怎么线性变换，利用这个公式，很好化的：(a&b)^(a&c) == a&(b^c)

//#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<cctype>
#include<string>
#include<algorithm>
#include<iostream>
#include<ctime>
#include<map>
#include<set>
using namespace std;
#define MP(x,y) make_pair((x),(y))
#define PB(x) push_back(x)
typedef long long LL;
//typedef unsigned __int64 ULL;
/* ****************** */
const int INF = 100011122;
const double INFF = 1e100;
const double eps = 1e-8;
const int mod = 1000000007;
const int NN = 110;
const int MM = 5000010;
/* ****************** */

int pri[NN], a[NN];
bool vis[10010];
int gss[NN][NN];

void init()
{
    int i, j, n = 10000, tol = 0;
    memset(vis, false, sizeof(vis));
    for(i = 2; i < n; i ++)
    {
        if(!vis[i])
        {
            pri[tol++] = i;
            if(tol == 100) return;
            for(j = i + i; j < n; j += i)
                vis[j] = true;
        }
    }
}
//返回行列式的秩，编号都从0开始
int gauss(int n,int m)
{
    int i, j, k, kk, pca;
   // int temp;
    for(i = 0, j = 0; i < n && j < m; i ++, j ++)
    {
        pca = i;
        for(k = i + 1; k < n; k ++)
        {
            if(abs(gss[k][j]) > abs(gss[pca][j]))
                pca = k;
        }
        if(pca != i)
        {
            for(k = j; k < m; k ++)
            {
                swap(gss[i][k], gss[pca][k]);
            }
        }
        if(gss[i][j] == 0)
        {
            i--;
            continue;
        }
        for(k = i + 1; k < n; k ++)
        {
          //  temp = gss[k][j]/gss[i][j];
            if(gss[k][j]==0) continue;
            gss[k][j] = 0;
            for(kk = j + 1; kk < m; kk ++)
            {
               // gss[k][kk] -= gss[i][kk]*temp;
               gss[k][kk] ^= gss[i][kk];
            }
        }
    }
    return i;
}

int main()
{
    init();
    LL A, B, limit = 10000000000000000LL;
    int ans;
    int t, m, n, i, j;
    while(scanf("%d%d",&n, &m) != EOF)
    {
        for(i = 0; i < m; i ++)
        {
            scanf("%d", &t);
            for(j = 0; j < n; j ++)
            {
                gss[j][i] = 0;
                while(t%pri[j] == 0)
                {
                    gss[j][i] ++;
                    t /= pri[j];
                }
                gss[j][i] %= 2;
            }
        }

        ans = m - gauss(n, m);

        A = B = 0;
        for(int i = 0; i < ans; i ++)
        {
            A <<= 1;
            B <<= 1;
            B ++;
            A += B/limit;
            B %= limit;
        }
        if(A == 0)
            printf("%lld\n",B);
        else
        {
            printf("%lld",A);
            printf("%016lld\n",B);
        }
    }
    return 0;
}