Sets 比赛时想错方向了。。。。 （大数不能处理负数啊）

Sets

Time Limit: 6000/3000MS (Java/Others) Memory Limit: 128000/64000KB (Java/Others)

SubmitStatus

Problem Description

给出N个数，现在需要将这些数分成若干个不相交的集合，同时给出M个限制集合，使得划分成的集合中，不能有任何一个集合包含给出的M个集合中的任意一个。求有多少种合法的集合划分方案

Input

多组数据，每组数据 ：

第一行N,M(1 <= N <= 100,0 <= M <= 10)

接下来M行，每行开始一个数TOT，表示这个禁止集合中的元素个数，接下来有TOT个数。(1 <= TOT <= N,且TOT个数都是1-N之间的正整数）

Output

每组数据，输出一行，你的答案

Sample Input

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

Sample Output

2
2
115975

Hint

第二个样例：

3个数的划分方案是 :

{1} {2} {3}

{1,2} {3}

{1,3} {2}

{1} {2,3}

{1,2,3}

因为划分方案中任意一组合法划分不能有一个集合包含 {1,2}或 {1,3}作为子集，所以"{1,2} {3}"，"{1,3} {2}"， "{1,2,3}"这3种划分方案不合法，合法方案为2

 #include <iostream>
 #include <string.h>
 #include <algorithm>
 #include <math.h>
 #include <stdio.h>
 using namespace std;

 #define MAXN 9999
 #define MAXSIZE 10
 #define DLEN 4

 class BigNum
 {
 private:
     int a[];    //可以控制大数的位数
     int len;       //大数长度
 public:
     BigNum()
     {
         len = ;    //构造函数
         memset(a,,sizeof(a));
     }
     BigNum(const int);       //将一个int类型的变量转化为大数
     BigNum(const char*);     //将一个字符串类型的变量转化为大数
     BigNum(const BigNum &);  //拷贝构造函数
     BigNum &operator=(const BigNum &);   //重载赋值运算符，大数之间进行赋值运算

     friend istream& operator>>(istream&,  BigNum&);   //重载输入运算符
     friend ostream& operator<<(ostream&,  BigNum&);   //重载输出运算符

     BigNum operator+(const BigNum &) const;   //重载加法运算符，两个大数之间的相加运算
     BigNum operator-(const BigNum &) const;   //重载减法运算符，两个大数之间的相减运算
     BigNum operator*(const BigNum &) const;   //重载乘法运算符，两个大数之间的相乘运算
     BigNum operator/(const int   &) const;    //重载除法运算符，大数对一个整数进行相除运算

     BigNum operator^(const int  &) const;    //大数的n次方运算
     int    operator%(const int  &) const;    //大数对一个int类型的变量进行取模运算
     bool   operator>(const BigNum & T)const;   //大数和另一个大数的大小比较
     bool   operator>(const int & t)const;      //大数和一个int类型的变量的大小比较

     void print();       //输出大数
 };
 BigNum::BigNum(const int b)     //将一个int类型的变量转化为大数
 {
     int c,d = b;
     len = ;
     memset(a,,sizeof(a));
     while(d > MAXN)
     {
         c = d - (d / (MAXN + )) * (MAXN + );
         d = d / (MAXN + );
         a[len++] = c;
     }
     a[len++] = d;
 }
 BigNum::BigNum(const char*s)     //将一个字符串类型的变量转化为大数
 {
     int t,k,index,l,i;
     memset(a,,sizeof(a));
     l=strlen(s);
     len=l/DLEN;
     if(l%DLEN)
         len++;
     index=;
     for(i=l-; i>=; i-=DLEN)
     {
         t=;
         k=i-DLEN+;
         if(k<)
             k=;
         for(int j=k; j<=i; j++)
             t=t*+s[j]-'';
         a[index++]=t;
     }
 }
 BigNum::BigNum(const BigNum & T) : len(T.len)  //拷贝构造函数
 {
     int i;
     memset(a,,sizeof(a));
     for(i =  ; i < len ; i++)
         a[i] = T.a[i];
 }
 BigNum & BigNum::operator=(const BigNum & n)   //重载赋值运算符，大数之间进行赋值运算
 {
     int i;
     len = n.len;
     memset(a,,sizeof(a));
     for(i =  ; i < len ; i++)
         a[i] = n.a[i];
     return *this;
 }
 istream& operator>>(istream & in,  BigNum & b)   //重载输入运算符
 {
     char ch[MAXSIZE*];
     int i = -;
     in>>ch;
     int l=strlen(ch);
     int count=,sum=;
     for(i=l-; i>=;)
     {
         sum = ;
         int t=;
         for(int j=; j<&&i>=; j++,i--,t*=)
         {
             sum+=(ch[i]-'')*t;
         }
         b.a[count]=sum;
         count++;
     }
     b.len =count++;
     return in;

 }
 ostream& operator<<(ostream& out,  BigNum& b)   //重载输出运算符
 {
     int i;
     cout << b.a[b.len - ];
     for(i = b.len -  ; i >=  ; i--)
     {
         cout.width(DLEN);
         cout.fill('');
         cout << b.a[i];
     }
     return out;
 }

 BigNum BigNum::operator+(const BigNum & T) const   //两个大数之间的相加运算
 {
     BigNum t(*this);
     int i,big;      //位数
     big = T.len > len ? T.len : len;
     for(i =  ; i < big ; i++)
     {
         t.a[i] +=T.a[i];
         if(t.a[i] > MAXN)
         {
             t.a[i + ]++;
             t.a[i] -=MAXN+;
         }
     }
     if(t.a[big] != )
         t.len = big + ;
     else
         t.len = big;
     return t;
 }
 BigNum BigNum::operator-(const BigNum & T) const   //两个大数之间的相减运算
 {
     int i,j,big;
     bool flag;
     BigNum t1,t2;
     if(*this>T)
     {
         t1=*this;
         t2=T;
         flag=;
     }
     else
     {
         t1=T;
         t2=*this;
         flag=;
     }
     big=t1.len;
     for(i =  ; i < big ; i++)
     {
         if(t1.a[i] < t2.a[i])
         {
             j = i + ;
             while(t1.a[j] == )
                 j++;
             t1.a[j--]--;
             while(j > i)
                 t1.a[j--] += MAXN;
             t1.a[i] += MAXN +  - t2.a[i];
         }
         else
             t1.a[i] -= t2.a[i];
     }
     t1.len = big;
     while(t1.a[len - ] ==  && t1.len > )
     {
         t1.len--;
         big--;
     }
     if(flag)
         t1.a[big-]=-t1.a[big-];
     return t1;
 }

 BigNum BigNum::operator*(const BigNum & T) const   //两个大数之间的相乘运算
 {
     BigNum ret;
     int i,j,up;
     int temp,temp1;
     for(i =  ; i < len ; i++)
     {
         up = ;
         for(j =  ; j < T.len ; j++)
         {
             temp = a[i] * T.a[j] + ret.a[i + j] + up;
             if(temp > MAXN)
             {
                 temp1 = temp - temp / (MAXN + ) * (MAXN + );
                 up = temp / (MAXN + );
                 ret.a[i + j] = temp1;
             }
             else
             {
                 up = ;
                 ret.a[i + j] = temp;
             }
         }
         if(up != )
             ret.a[i + j] = up;
     }
     ret.len = i + j;
     while(ret.a[ret.len - ] ==  && ret.len > )
         ret.len--;
     return ret;
 }
 BigNum BigNum::operator/(const int & b) const   //大数对一个整数进行相除运算
 {
     BigNum ret;
     int i,down = ;
     for(i = len -  ; i >=  ; i--)
     {
         ret.a[i] = (a[i] + down * (MAXN + )) / b;
         down = a[i] + down * (MAXN + ) - ret.a[i] * b;
     }
     ret.len = len;
     while(ret.a[ret.len - ] ==  && ret.len > )
         ret.len--;
     return ret;
 }
 int BigNum::operator %(const int & b) const    //大数对一个int类型的变量进行取模运算
 {
     int i,d=;
     for (i = len-; i>=; i--)
     {
         d = ((d * (MAXN+))% b + a[i])% b;
     }
     return d;
 }
 BigNum BigNum::operator^(const int & n) const    //大数的n次方运算
 {
     BigNum t,ret();
     int i;
     if(n<)
         exit(-);
     if(n==)
         return ;
     if(n==)
         return *this;
     int m=n;
     while(m>)
     {
         t=*this;
         for( i=; i<<<=m; i<<=)
         {
             t=t*t;
         }
         m-=i;
         ret=ret*t;
         if(m==)
             ret=ret*(*this);
     }
     return ret;
 }
 bool BigNum::operator>(const BigNum & T) const   //大数和另一个大数的大小比较
 {
     int ln;
     if(len > T.len)
         return true;
     else if(len == T.len)
     {
         ln = len - ;
         while(a[ln] == T.a[ln] && ln >= )
             ln--;
         if(ln >=  && a[ln] > T.a[ln])
             return true;
         else
             return false;
     }
     else
         return false;
 }
 bool BigNum::operator >(const int & t) const    //大数和一个int类型的变量的大小比较
 {
     BigNum b(t);
     return *this>b;
 }

 void BigNum::print()    //输出大数
 {
     int i;
     cout << a[len - ];
     for(i = len -  ; i >=  ; i--)
     {
         cout.width(DLEN);
         cout.fill('');
         cout << a[i];
     }
 }
 BigNum dp[][];
 void init()
 {
     int i,j;
     dp[][]=;
     for(i=; i<; i++)
     {
         dp[i][]=;
         for(j=; j<=i; j++)
             dp[i][j]=dp[i-][j]*j+dp[i-][j-];
     }
     for(i=; i<; i++)
     {
         for(j=; j<=i; j++)
             dp[i][]=dp[i][]+dp[i][j];
     }
     dp[][]=;
 }
 int a[][],n,m;
 int father[];
 BigNum ans,ans1;
 int findfa(int x)
 {
     return father[x] == x ? x : father[x] = findfa(father[x]);
 }
 void solve(int x)
 {
     int i,j,y,z,nm=n;
     bool bi=;
     for(i=; i<=n; i++)father[i]=i;
     for(i=; i<m; i++)
     {
         if(x&(<<i))
         {
             bi^=;
             if(a[i][]==)continue;
             y=findfa(a[i][]);
             for(j=; j<=a[i][]; j++)
             {
                 z=findfa(a[i][j]);
                 if(z!=y)
                     father[z]=y,nm--;
             }
         }
     }
     if(bi)ans1=ans1+dp[nm][];
     else ans=ans+dp[nm][];
 }
 void work()
 {
     int i,j,len=(<<m);
     ans1=ans=;
     for(i=; i<len; i++)
     {
         solve(i);
     }
     ans=ans-ans1;
     ans.print();
     printf("\n");
 }
 int main(void)
 {
     init();
     int i,j;
     while(~scanf("%d%d",&n,&m))
     {
         for(i=; i<m; i++)
         {
             scanf("%d",&a[i][]);
             for(j=; j<=a[i][]; j++)
                 scanf("%d",&a[i][j]);
         }
         work();
     }
 }